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

Scrape product search results from Naver Shopping (search.shopping.naver.com). Extracts product titles, prices, sellers, ratings, shipping info, and more. Ideal for price comparison, market research, and product monitoring in the Korean market.

- **URL**: https://apify.com/searchapi/naver-shopping-scraper.md
- **Developed by:** [Search API](https://apify.com/searchapi) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Stats:** 7 total users, 1 monthly users, 16.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 search results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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 Brand-Store Search

This Actor enters product keywords into the search form of public `brand.naver.com` stores and extracts the product cards returned by the website. It supports one query or a batch of queries, bounded pagination, three website sort modes, and optional authorized proxies.

### Search scope

Naver's general Shopping result origin returns HTTP 418 or maintenance responses from many data-center environments. This Actor therefore uses Naver's public autocomplete service to select a relevant brand store, then performs the requested search inside that store. Every record declares `searchScope: "brand-store"` and includes the selected store name and URL. To select the store yourself, provide one public `https://brand.naver.com/<store>` URL in `startUrls`.

This is not a claim of marketplace-wide coverage. If autocomplete cannot find a public brand store for a query, provide a brand-store URL or use a more brand-specific query.

### Inputs

- `query`: one product keyword, such as `노트북`.
- `queries`: additional product keywords for batch mode.
- `startUrls`: optional public Naver brand stores. One URL can be reused for all queries, or paired with queries by position.
- `sortBy`: `relevance`, `newest`, or `reviews`.
- `maxItemsPerQuery`: maximum products stored for each keyword (1–200).
- `maxPages`: maximum website pages opened per keyword (1–20).
- `maxConcurrency`: simultaneous query searches (1–10).
- `maxRequestRetries`: bounded retries for temporary browser or network errors.
- `navigationTimeoutSecs` and `requestHandlerTimeoutSecs`: timeouts.
- `proxyConfiguration`: Apify Proxy or user-provided proxy URLs. An explicit disabled setting is honored.

The legacy `maxItems` input is still accepted as an alias for `maxItemsPerQuery`.

### Output

Records contain source-backed values only. Required identity, URL, pricing, store, query, position, source, and timestamp fields are always present. `reviewCount` and `rating` are omitted when the website does not show review data; `hasReviews` remains present so consumers can distinguish that case.

Important fields include:

- stable `id` and `productId`;
- canonical `productUrl` without expiring click signatures;
- `title`, `imageUrl`, `price`, `priceNumeric`, and `currency`;
- `rating`, `reviewCount`, and `hasReviews`;
- `brandStoreName`, `brandStoreUrl`, and `categoryId`;
- `position`, `page`, `pagePosition`, and `resultTotal`;
- `searchQuery`, `sortBy`, `searchScope`, and `searchUrl`;
- `source`, `extractionMethod`, and ISO-8601 `scrapedAt`.

### Extraction behavior

The Actor first uses Naver's structured autocomplete JSON to discover a store, validating status and content type before parsing it. Naver does not expose a reliable structured response for the query-specific cards in the observed store-search flow, so the cards use a DOM fallback based on stable semantic and tracking attributes. Challenge or block pages are rejected and never stored.

The Actor uses persistent crawler sessions, a consistent desktop browser profile, bounded retries, and optional authorized proxies. It does not solve or bypass CAPTCHAs, login requirements, or access controls.

### Example

```json
{
  "query": "노트북",
  "queries": ["모니터"],
  "startUrls": [{ "url": "https://brand.naver.com/samsung" }],
  "sortBy": "relevance",
  "maxItemsPerQuery": 20,
  "maxPages": 2,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

Run locally with:

```bash
apify run --purge --input-file INPUT.json
```

# Actor input Schema

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

A product keyword to enter in the Naver brand-store search form.

## `queries` (type: `array`):

Optional additional keywords. Each query is searched independently.

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

Optional public brand.naver.com store URLs. One URL can be reused for every query, or URLs can be paired by position with the queries.

## `sortBy` (type: `string`):

The ordering to select in the website result controls.

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

Stop after this many unique product cards for each keyword.

## `maxPages` (type: `integer`):

Maximum number of website pagination pages to open for each keyword.

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

Maximum number of keyword searches to run simultaneously.

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

Retry temporary browser or network failures at most this many times.

## `navigationTimeoutSecs` (type: `integer`):

Maximum time allowed for the initial store navigation.

## `requestHandlerTimeoutSecs` (type: `integer`):

Maximum time allowed for one keyword search including pagination.

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

Use Apify Proxy or your own proxy URLs when authorized. The Actor honors an explicit disabled setting.

## Actor input object example

```json
{
  "query": "노트북",
  "queries": [],
  "startUrls": [],
  "sortBy": "relevance",
  "maxItemsPerQuery": 40,
  "maxPages": 5,
  "maxConcurrency": 2,
  "maxRequestRetries": 1,
  "navigationTimeoutSecs": 45,
  "requestHandlerTimeoutSecs": 90,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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("searchapi/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("searchapi/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 searchapi/naver-shopping-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,searchapi/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/cCBwDlGACTd26dw0V/builds/EVaBFxKbHhhgTO4C0/openapi.json