# Naver Shopping Product Scraper (`automation-lab/naver-shopping-product-scraper`) Actor

Scrape public Naver shopping products by Korean keyword. Get prices, discounts, sellers, shipping, ratings, review counts, sponsored flags, images, ranks, and URLs for ecommerce research and monitoring.

- **URL**: https://apify.com/automation-lab/naver-shopping-product-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 3 total users, 2 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $15.60 / 1,000 naver 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/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

## Naver Shopping Product Scraper

Collect public Naver shopping products for Korean keywords as clean records with prices, discounts, sellers, delivery details, ratings, reviews, sponsored-result flags, images, ranks, and URLs.

Use the Actor for Korean ecommerce price research, seller comparisons, assortment checks, and scheduled market snapshots. It needs no Naver account and does not access carts, orders, member profiles, or other private data.

### What does Naver Shopping Product Scraper do?

The Actor searches Naver's public integrated shopping results and writes one dataset row per product card.

It accepts one to ten Korean product keywords. For each keyword it:

1. opens Naver's public mobile shopping-search surface;
2. validates the response and extracts its embedded structured product state;
3. falls back to desktop public search when needed;
4. uses a Korean residential browser only when public HTTP routes do not return recognizable data;
5. normalizes products into a stable dataset schema;
6. removes duplicate product IDs within each query;
7. optionally excludes sponsored products.

The default route is lightweight HTTP. It avoids downloading product images and product-detail pages because the list cards already contain the promised fields.

### Who is it for?

**Ecommerce analysts** can compare advertised and organic prices across Korean product searches.

**Marketplace sellers** can review visible competitors, discounts, delivery fees, ratings, and review counts.

**Brand teams** can capture ranked search snapshots and identify sponsored placements.

**Data engineers** can schedule the Actor and load typed JSON records into spreadsheets, warehouses, dashboards, or monitoring jobs.

**Researchers** can gather public shopping records without building and maintaining Naver routing, parsing, and restriction detection.

### Data you can extract

| Field | Meaning |
| --- | --- |
| `productId` | Stable Naver shopping product identifier |
| `title` | Product title with search highlighting removed |
| `url` | Product or Naver shopping destination URL |
| `imageUrl` | Main public product image URL, when available |
| `sellerName` | Seller, store, or catalog name |
| `sellerUrl` | Public seller/store URL, when available |
| `currentPrice` | Current or discounted price |
| `listPrice` | Original price before the displayed discount |
| `currency` | Price currency, normally `KRW` |
| `discountPercent` | Displayed discount percentage |
| `shippingFee` | Displayed shipping fee; `0` can mean free shipping |
| `shippingType` | Naver delivery fee or speed classification |
| `rating` | Average public rating |
| `reviewCount` | Public review count |
| `purchaseCount` | Public purchase count when shown |
| `inStock` | Stock flag when Naver publishes it; otherwise `null` |
| `isAd` | Whether Naver marks the result as sponsored |
| `isBrandStore` | Whether the result is associated with a brand store |
| `query` | Input keyword that produced the row |
| `rank` | Rank supplied by the Naver shopping card |
| `source` | Successful extraction route |
| `scrapedAt` | UTC collection timestamp |

Nullable fields remain `null` rather than being guessed. In particular, Naver's integrated search cards do not always expose stock.

### Getting started

1. Open the Actor input page.
2. Enter one or more Korean product keywords.
3. Choose the maximum number of product records.
4. Keep **Auto** routing unless you specifically need a Korean residential browser.
5. Choose whether to include sponsored products.
6. Click **Start**.
7. Open the **Naver products** dataset view when the run finishes.

A small first run:

```json
{
  "keywords": ["노트북"],
  "maxItems": 9,
  "includeAds": true,
  "routing": "auto"
}
```

### Input parameters

#### `keywords`

Required array of one to ten non-empty search terms.

Korean queries generally match the source best. Examples:

- `노트북` — laptop
- `로봇청소기` — robot vacuum
- `무선 이어폰` — wireless earbuds
- `보조배터리` — portable charger

#### `maxItems`

Maximum records across all keywords, from 1 to 90. The Actor shares this capacity fairly across keywords so an earlier search cannot consume the entire limit before later searches run.

The public Naver surface currently exposes about nine shopping cards per keyword. Adding more keywords can produce more rows; increasing only `maxItems` does not create pages the source does not publish.

#### `includeAds`

When `true`, sponsored and organic cards are included. Every row exposes `isAd`.

When `false`, sponsored cards are removed before saving and are not charged as item events.

#### `routing`

- `auto` — recommended; mobile public HTTP, desktop public HTTP, then a Korean residential browser only if required.
- `residentialBrowser` — forces the Korean residential browser route for testing or difficult network conditions. It uses more compute and proxy traffic.

The Actor keeps the browser proxy identity, locale, timezone, and cookies together for the bounded request. It does not ask for a Naver login.

### Output example

This shortened record reflects current local output for `노트북`:

```json
{
  "productId": "84417974537",
  "title": "베이직북14 사무용 가벼운 노트북 업무용 인강용 싼 저가 윈도우11 8GB/256GB",
  "url": "https://smartstore.naver.com/main/products/6873474215",
  "imageUrl": "https://shopping-phinf.pstatic.net/main_8441797/84417974537.14.jpg",
  "sellerName": "베이직스 스토어",
  "currentPrice": 598000,
  "listPrice": 959000,
  "currency": "KRW",
  "discountPercent": 37,
  "shippingFee": 0,
  "shippingType": "FREE",
  "rating": 4.77,
  "reviewCount": 14000,
  "purchaseCount": 2383,
  "inStock": null,
  "isAd": false,
  "isBrandStore": false,
  "query": "노트북",
  "rank": 1,
  "source": "mobile-public-search",
  "scrapedAt": "2026-08-03T04:22:04.429Z"
}
```

Prices and listings change. Treat this as a schema example, not a current product offer.

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

This Actor uses pay per event pricing:

- one `start` event per run;
- one `item` event for each validated product saved to the default dataset.

The start event is **$0.005**. Item prices decrease by Apify pricing tier:

| Tier | Price per product |
| --- | ---: |
| Free | $0.02990 |
| Bronze | $0.02600 |
| Silver | $0.02028 |
| Gold | $0.01560 |
| Platinum | $0.01040 |
| Diamond | $0.00728 |

At the Free-tier rate, a run producing 9 products costs about **$0.2741** including the start event. A two-keyword run producing 18 products costs about **$0.5432**.

You are charged only for validated rows that are saved. Filtered sponsored cards, duplicate records, parse failures, and empty results do not create item charges. Platform usage behavior follows the active Apify pricing configuration shown before you start the run.

### Price monitoring workflow

To create repeatable snapshots:

1. use stable Korean keywords;
2. keep `includeAds` consistent across runs;
3. schedule the Actor daily or weekly in Apify Console;
4. export each dataset to your storage destination;
5. join snapshots on `query` and `productId`;
6. compare `currentPrice`, `sellerName`, `shippingFee`, `rank`, `rating`, and `reviewCount` over time.

The Actor returns current observations. It does not keep historical rows or calculate changes inside the run.

### Seller and sponsored-result research

Set `includeAds` to `true` when you need the complete visible mix and separate records using `isAd`.

Set it to `false` when you need an organic comparison dataset. This can reduce the output significantly because some searches contain several sponsored cards.

Catalog cards may represent multiple stores. In those rows, seller information can be empty while `isBrandStore` and the catalog URL remain useful.

### Integrations and exports

The default dataset works with:

- CSV, JSON, Excel, XML, RSS, and JSONL exports;
- Google Sheets through Apify integrations;
- scheduled webhooks;
- Make and Zapier workflows;
- Python or JavaScript data pipelines;
- warehouse loaders and BI dashboards.

Use `productId` with `query` as the practical snapshot key. The same product can appear for more than one keyword by design.

### API usage with cURL

Replace `YOUR_TOKEN` with an Apify API token:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~naver-shopping-product-scraper/runs?token=YOUR_TOKEN&waitForFinish=120" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["노트북"],"maxItems":9,"includeAds":true,"routing":"auto"}'
```

Fetch dataset items using the `defaultDatasetId` returned by the run API.

### JavaScript API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/naver-shopping-product-scraper').call({
    keywords: ['무선 이어폰', '보조배터리'],
    maxItems: 18,
    includeAds: true,
    routing: 'auto',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/naver-shopping-product-scraper').call(run_input={
    'keywords': ['로봇청소기'],
    'maxItems': 6,
    'includeAds': False,
    'routing': 'auto',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI agents

Add the Actor-scoped Apify MCP server to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/naver-shopping-product-scraper"
```

#### Claude Desktop, Cursor, and VS Code MCP setup

Use this MCP configuration in Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/naver-shopping-product-scraper"
    }
  }
}
```

Example prompts:

- “Run the Naver Shopping Product Scraper for `노트북` and summarize the lowest current prices by seller.”
- “Collect organic `로봇청소기` products and return their ratings, review counts, prices, and URLs.”
- “Create a dataset for `무선 이어폰` and `보조배터리`, then group sponsored and organic products.”

### Reliability and routing

The Actor validates HTTP status, the expected embedded state, and typed product fields before saving rows.

Transient network and 5xx responses receive one bounded retry with jitter. Deterministic input errors do not retry.

Auto routing tries:

1. mobile Naver public search;
2. desktop Naver public search;
3. a Korean residential Playwright browser with media and fonts blocked.

If all routes fail, the run fails visibly instead of returning a misleading successful empty dataset.

### Limitations

- Current coverage is the product cards Naver exposes in integrated search, typically about nine per keyword.
- The Actor does not promise the protected Naver Shopping site's deep pagination.
- Naver can vary result order by time, location, experiments, and advertising.
- Stock is `null` when the public card omits it; the Actor never invents availability.
- Some catalog cards omit a single seller or direct seller URL.
- Ratings, review counts, prices, promotions, and delivery details can change after collection.
- Adult, login-only, cart, order, account, and member-only data are out of scope.
- The Actor does not open product-detail pages or scrape product reviews.

### Troubleshooting

#### My run returned fewer products than `maxItems`

`maxItems` is a cap, not a promised count. Naver currently publishes a bounded set of cards per keyword, and excluding ads can remove several rows. Add materially different keywords when that matches your research job.

#### My run failed with “embedded shopping state missing”

Naver returned an unfamiliar or restricted page. Retry once later with `routing` set to `residentialBrowser`. If the forced route also fails, inspect the run log rather than treating the empty page as valid data.

#### Why is `inStock` null?

The public search card did not publish a stock field. Use null-aware downstream logic and do not interpret null as out of stock.

#### Why do ranks repeat?

Naver supplies ranks within card groups such as ads, promoted products, catalogs, and organic results. Use `isAd`, `source`, and dataset order alongside `rank`.

### Responsible use and legality

This Actor processes publicly visible Naver search information. You are responsible for ensuring that your collection and use comply with Naver's terms, applicable laws, intellectual-property rights, privacy obligations, and your organization's policies.

Use conservative schedules. Do not attempt to identify individuals, bypass account controls, or collect private order/member data. Avoid republishing protected images or product copy without the necessary rights.

### Related Automation Lab Actors

- [Naver DataLab Search Trends Scraper](https://apify.com/automation-lab/naver-datalab-search-trends-scraper) — compare Korean search-interest trends when product listing data alone is not enough.
- [Naver News Search Scraper](https://apify.com/automation-lab/naver-news-search-scraper) — collect public Naver news results for brand and market monitoring.

These Actors produce separate datasets and are not automatically invoked by this product scraper.

### FAQ

#### Does the Actor require a Naver account?

No. It uses public search surfaces and never asks for Naver credentials.

#### Can it search English keywords?

Naver may return products for English queries, but Korean keywords generally provide the most relevant marketplace results.

#### Can I exclude sponsored products?

Yes. Disable sponsored-product inclusion. Excluded cards never enter the dataset or item-event count.

#### Does it scrape reviews?

No. It returns the rating and review count shown on the search card, not individual review text.

#### Does it support multiple keywords?

Yes, up to ten keywords per run and up to 90 total records.

#### Can I use the results for scheduled monitoring?

Yes. Schedule repeated runs and compare exported snapshots externally. The Actor itself does not maintain history or send change alerts.

#### What happens when Naver blocks a route?

Auto routing tries the next bounded route. If no route provides recognizable structured state, the run fails with route-specific reasons rather than silently returning bad data.

# Actor input Schema

## `keywords` (type: `array`):

One to ten product searches, such as 노트북 (laptop) or 무선 이어폰 (wireless earbuds).

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

Maximum number of product records across all keywords. Capacity is shared fairly across keywords so one search does not consume the full limit. The public search surface currently returns up to about nine products per keyword.

## `includeAds` (type: `boolean`):

Include records marked as sponsored by Naver. Every record exposes isAd so you can filter it later.

## `routing` (type: `string`):

Auto uses lightweight public search first and a Korean residential browser only if needed. Residential browser forces the protected-route fallback for difficult network conditions and costs more to run.

## Actor input object example

```json
{
  "keywords": [
    "노트북"
  ],
  "maxItems": 20,
  "includeAds": true,
  "routing": "auto"
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset in its product comparison table view.

# 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 = {
    "keywords": [
        "노트북"
    ],
    "maxItems": 20,
    "includeAds": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/naver-shopping-product-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 = {
    "keywords": ["노트북"],
    "maxItems": 20,
    "includeAds": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/naver-shopping-product-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 '{
  "keywords": [
    "노트북"
  ],
  "maxItems": 20,
  "includeAds": true
}' |
apify call automation-lab/naver-shopping-product-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/1Vh6RmRRrNxeHWem1/builds/EfGY0df0JzqjX0rCH/openapi.json