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

Search Naver Shopping for product prices, sellers, brands, categories, ratings, reviews, and source links. Use for Korean ecommerce price research; not product-detail or review scraping.

- **URL**: https://apify.com/khadinakbar/naver-product-shopping-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $60.00 / 1,000 product 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

## Naver Product Shopping Scraper

**Naver Product Shopping Scraper** searches Naver Shopping and returns one normalized product comparison record per result. It is for Korean ecommerce teams, catalog analysts, and price-monitoring workflows that need current product titles, prices, sellers, brands, categories, ratings, review counts, product links, and collection timestamps.

Use it for Naver Shopping search-result research. Do not use it for full SmartStore or Brand Store catalogs, per-SKU product details, or review-text collection; those are different jobs with different data shapes.

### What it extracts

Each dataset item represents a single public Naver Shopping search result. The actor normalizes `productId`, `title`, `productUrl`, `priceKrw`, `originalPriceKrw`, `discountPercent`, seller and brand data, category labels, rating, review count, `sourceUrl`, and `scrapedAt`. It uses explicit `null` values when Naver does not expose a field.

### When to use it

Use this actor to compare Naver Shopping offers for a keyword, monitor broad product coverage, or prepare a price-intelligence dataset for another workflow. Start with a small `maxResults` value to confirm the current result shape and cost.

Do not use it when you already have Naver SmartStore or Brand Store product URLs and need variant-level stock, long-form descriptions, or legal disclosures. It also does not collect review text or bypass login-only content.

### Input

```json
{
  "searchQueries": ["wireless earbuds", "무선 이어폰"],
  "maxResults": 20
}
```

- `searchQueries` accepts up to 20 product phrases.
- `maxResults` is both the dataset and product-result billing cap, from 1 to 200.
- The actor uses persistent Korean residential browser sessions internally, with an owner-configured residential fallback for Naver's IP-reputation blocks; no Naver API key or cookie is accepted as input.

### Output

```json
{
  "productId": "1234567890",
  "title": "Wireless Bluetooth Earbuds",
  "productUrl": "https://search.shopping.naver.com/catalog/1234567890",
  "priceKrw": 59900,
  "sellerName": "Example Mall",
  "brand": "Example Brand",
  "rating": 4.8,
  "reviewCount": 123,
  "sourceUrl": "https://search.shopping.naver.com/search/all?query=wireless%20earbuds",
  "scrapedAt": "2026-07-14T12:00:00.000Z"
}
```

The default key-value store also contains `OUTPUT` for the compact terminal outcome and `RUN_SUMMARY` for safe diagnostic, coverage, and billing counters. Valid queries with no matches return `VALID_EMPTY`; malformed input returns `INVALID_INPUT`; a blocked upstream route with no usable result fails honestly as `UPSTREAM_FAILED`.

### Pricing

This actor uses **Pay per event + usage**: actor start is **$0.00005** per run and each validated product result is **$0.06**. The price supports the reliable managed Korean search route; Apify platform usage is charged separately. The managed route invokes a separate Apify Actor under the same account, so its own provider events can also appear in account billing. A 20-result run has at most **$1.20005** in this actor's events, plus platform usage and any managed-route provider events.

### API and MCP use

Run the actor through the Apify Console, API, schedules, or Apify MCP. For an agent, supply a concise product phrase and a bounded `maxResults`, then read the dataset through the run’s default dataset endpoint. Each item includes `sourceUrl` and `scrapedAt` so downstream steps can retain provenance.

### Limits and reliability

Naver may vary search-result fields by query, region, and current site behavior. The actor uses a browser response collector with a DOM fallback, validates every completed record before it is persisted, and keeps a single browser session per request. A Korean residential proxy is required because Naver can reject direct non-Korean HTTP traffic.

### Legal and responsible use

Use this actor only for data you are authorized to collect and process, and comply with applicable law, Naver’s rules, and downstream data-use obligations. Do not use it to collect login-only data, circumvent access controls, or process personal data without a lawful basis.

### Feedback

If a specific search phrase starts returning an unexpected shape, include the run ID, query, and a redacted example of the affected record when reporting the issue. That lets us distinguish a query-specific empty result from a site-shape change.

# Actor input Schema

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

Use this when you need current Naver Shopping search results for one or more product phrases. Enter plain-text queries such as 'wireless earbuds' or '무선 이어폰'; Korean and English are attempted with the same browser workflow. The default runs one small representative search and each query is limited to 200 characters. This is not a product-detail URL input—use a dedicated detail scraper for per-SKU inventory or long descriptions.

## `maxResults` (type: `integer`):

Use this when you need to cap both returned product records and product-result charges. Enter an integer from 1 to 200, for example 20; the default is 20 and the actor stops writing and charging at this cap. A value of 100 can cost up to $0.600 in product-result events plus Apify platform usage. This is a result limit, not a number of search-result pages or a promise of that many matches.

## Actor input object example

```json
{
  "searchQueries": [
    "wireless earbuds"
  ],
  "maxResults": 20
}
```

# Actor output Schema

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

Product comparison records with price, seller, brand, category, ratings, reviews, source URL, and collection time.

## `output` (type: `string`):

Compact machine-readable terminal outcome and item/charge counters.

## `runSummary` (type: `string`):

Detailed diagnostic, coverage, and billing summary for the 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 = {
    "searchQueries": [
        "wireless earbuds"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/naver-product-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 = {
    "searchQueries": ["wireless earbuds"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/naver-product-shopping-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 '{
  "searchQueries": [
    "wireless earbuds"
  ],
  "maxResults": 20
}' |
apify call khadinakbar/naver-product-shopping-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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