# Naver Shopping Scraper: Korea Prices, Sellers, Review Counts (`vant47/naver-shopping-scraper`) Actor

Get Naver Shopping (네이버쇼핑) products for any keyword: prices, sellers, ratings, review counts and ad flags for laptops, coffee or skincare. About $0.0034 per product: 1,000 cost $3.40. No login. Public search snapshots; full mall offers and review text are unavailable.

- **URL**: https://apify.com/vant47/naver-shopping-scraper.md
- **Developed by:** [fortbrand](https://apify.com/vant47) (community)
- **Categories:** E-commerce, Automation
- **Security:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.72 / 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

## Naver Shopping Scraper: Korea Prices, Sellers, Review Counts

For pricing teams, Korean marketplace researchers and brands that need repeatable product-search snapshots from Naver Shopping (네이버쇼핑). Search in Korean or English and export displayed prices, seller names, catalog references, ratings, review counts, ad flags and product links.

About **$0.0034 per unique product** before plan discounts. A 20-product check costs about **$0.07**, and 1,000 delivered products cost **$3.40**, plus the small Actor start fee. No Naver login or developer key is required.

**Coverage:** this Actor reads the shopping cards embedded in public mobile Naver search, including the standard list and Explore shopping layouts. It does not deliver full catalog detail pages, every mall's offer table or review text. Snapshot size depends on the keyword and shopping layout, typically up to 150 cards per keyword and sometimes fewer. Prices and review counts are live observations of those cards.

### What you get

Products can be comparison catalogs or single-store listings. `catalogId` and `lowestPrice` distinguish their prices. Every row retains its source and observation time.

| Field | Meaning |
| --- | --- |
| `verdict` | A short description of the displayed price and seller or comparison |
| `recordType` | `PRODUCT`, a free `NOTE`, or the free `SUMMARY` |
| `productId` | Naver shopping-search product identifier, stored as text |
| `catalogId` | Price-comparison catalog identifier, when the card supplies one |
| `title` | Product name with search highlighting removed |
| `brand`, `maker`, `category` | Names only when supplied; otherwise `null` |
| `price` | Displayed discounted product price, before shipping |
| `lowestPrice` | Displayed catalog comparison price; `null` for a single-store listing |
| `currency` | Currency supplied by Naver, normally `KRW` |
| `regularPrice` | Positive price before the displayed discount, when supplied |
| `onSale`, `discountPercent` | Comparison with regular price and the source's discount percentage |
| `mallName` | Public store name; a catalog comparison can have no single mall |
| `mallCount` | Catalog's source-reported listing count; not a verified count of unique retailers |
| `offers` | With `includeOffers`, the one displayed offer of a single-store card |
| `offersComplete` | `false` when offers were requested; this is not an all-mall table |
| `shippingFee` | Card's stated shipping fee; catalog shipping can vary across sellers |
| `rating`, `reviewCount` | Public average score and review count; no reviewer identities |
| `purchaseCount` | Positive purchase count when shown; absent or zero placeholders become `null` |
| `isAd` | Whether Naver identifies the card as an advertisement |
| `promotionTypes` | Promotion identifiers supplied on the card |
| `unitPrice`, `unitOfMeasure` | Unit-price information when present |
| `categoryId`, `categoryIds` | Leaf category and category-ID chain |
| `channelProductId` | Store product identifier, when present; a different namespace from `productId` |
| `imageUrl`, `url` | Main image and product or catalog page |
| `keyword`, `sourceUrl`, `sourceRank` | Search term, public source page and original card position |
| `cardType`, `sortApplied` | Source card kind and whether sorting was source order or within the snapshot |
| `scrapedAt`, `coverage` | UTC observation time and a concise coverage explanation |

Missing fields remain `null`. The Actor does not guess a brand from the title, turn a category ID into an invented category name or treat every zero purchase count as a reported sale count.

### Use with AI agents (MCP)

An assistant connected to the [Apify MCP server](https://mcp.apify.com) can call `vant47/naver-shopping-scraper` with `searchTerms` and `maxItems`. Ask for 20 Korean wireless-earphone listings with prices, sellers, ratings, review counts and ad flags.

Filter results to `recordType == "PRODUCT"` and read `SUMMARY`. Price ordering applies within the public snapshot. Empty or restricted responses produce free notes, never invented products.

### Start in three steps

1. Enter one or more `searchTerms`, preferably specific product words in Korean. English model and brand searches also work.
2. Set `maxItems`. Start with 20. Choose an optional price band or sort order.
3. Run the Actor and open the Products and prices dataset view. Export JSON, CSV or Excel, or retrieve the dataset through the API.

The prefilled input is:

```json
{
  "searchTerms": ["무선 이어폰"],
  "maxItems": 20
}
```

A live cloud check on 29 October 2026 delivered 20 unique products in **11.7 seconds**. It recorded 20 product charges. Runtime varies with source response time and retries.

### Inputs

| Input | Default | How it works |
| --- | --- | --- |
| `searchTerms` | Prefill: `무선 이어폰` | Array of Korean or English product searches; up to 100 terms |
| `startUrls` | Empty | Optional Naver search links containing `query=`; strings or objects with `url` |
| `sort` | `relevance` | `relevance`, `priceAsc`, `priceDesc`, `reviews` or `newest`; see the sort limits below |
| `priceMin`, `priceMax` | Unset | Inclusive KRW band applied to the returned snapshot |
| `maxItems` | `20` | Global unique-product limit, from 1 to 10,000, across all inputs |
| `includeOffers` | `false` | Adds the one displayed offer on a single-store card; no extra charge |
| `includeReviews` | `false` | Review text is unavailable; requesting it adds a free coverage note |
| `maxReviews` | `20` | Reserved for review-text collection, currently unavailable |
| `proxyConfiguration` | Apify proxy on | Datacenter first; fresh sessions, then direct cloud and Korean residential recovery when needed |

`relevance` keeps Naver's card order. Price sorts and `reviews` reorder only the cards in the returned snapshot. They do not issue a marketplace-wide lowest-price or most-reviewed query. The source does not provide listing dates, so `newest` returns a note and preserves source relevance order. `sortApplied` makes the behavior explicit on each row.

`maxItems` limits unique products across inputs. Filters, snapshot size and the spending limit can reduce output. Searches run in input order; an early search can fill the limit. Use separate tasks for independent allocations.

#### Compare a price band

```json
{
  "searchTerms": ["캠핑 의자"],
  "sort": "priceAsc",
  "priceMin": 20000,
  "priceMax": 100000,
  "maxItems": 30,
  "includeOffers": true
}
```

This sorts qualifying camping-chair cards from low to high. Store cards can include one offer; catalog cards keep `offers` empty because the full table is unavailable.

#### Use a saved Naver search link

```json
{
  "startUrls": [
    "https://search.shopping.naver.com/search/all?query=커피"
  ],
  "maxItems": 20
}
```

Desktop shopping-search links are translated to their query on the supported mobile surface. The Actor also accepts `msearch.shopping.naver.com`, `search.naver.com` and `m.search.naver.com` search links. A `catId` on a search URL filters the returned category-ID chains. Use the top-level price and sort inputs to control those options; other parameters on a pasted URL do not reproduce the desktop page's filters.

A standalone `/catalog/123...` URL or a category URL without a search term produces a free note explaining the limitation. It does not return a search substitute for an unrelated product. Links outside the supported Naver hosts are skipped.

### Reading the results correctly

Products and prices emphasizes prices, sellers, ratings and ads. Displayed discounts shows discount fields and promotions; export `onSale == true` for discounted products only. All product fields includes identifiers and coverage notes.

A dataset ends with one free `SUMMARY` row. A matching `SUMMARY` record is also saved in the default key-value store. It lists delivered products, catalog products, malls represented, ads, discounts, requested searches, available cards, source failures and whether the spending limit stopped collection. Notes and summary rows have no product charge.

Repeated identifiers are delivered once per run, including overlap across keywords and placements. The first observation wins. Later scheduled runs deliberately create fresh observations for price monitoring.

### Monitor prices every day

Save a working input as an Apify task and attach a daily schedule. Keep terms, filters, sort and limits consistent. The Actor does not create schedules itself.

Join dated runs on `productId`; use `catalogId` for comparison catalogs. Keep `price`, `mallName`, `isAd` and `scrapedAt`. A changed rank can reflect ads or snapshot composition rather than market share.

Thirty daily 20-product runs cost about $2.04 at list product prices, plus start fees. Export to Sheets, n8n, Make, Zapier, webhooks or a database. Keep timestamps so yesterday's price stays identified as yesterday's observation.

### Price and spending controls

| Delivered products | List product charge | Bronze product charge |
| ---: | ---: | ---: |
| 20 | $0.068 | $0.0646 |
| 100 | $0.34 | $0.323 |
| 1,000 | $3.40 | $3.23 |

List price is $0.0034 per Product. Bronze receives 5% off, Silver 10% and Gold and higher tiers 20%. Apify's start event is $0.00005 per GB, with at least one start unit. Platform usage is included in the product pricing. There is no extra dataset-item fee and no offer or review event.

Set a maximum charge in Apify's run options to cap a job. The Actor checks remaining capacity before fetching another search and before delivering another product. It saves the row before charging it and stops cleanly when the limit cannot cover another product. Duplicates, failed searches, unavailable catalog detail, coverage notes and empty results do not incur product charges. A start fee can still apply to an empty run.

If Apify reboots or migrates a run, saved snapshots, dataset identifiers and acknowledged event counts are reused. Already delivered products are skipped and already accepted charges are reconciled. This keeps a resumed run from billing the same product a second time.

### API examples

Keep your Apify token in an application secret. A synchronous request returns dataset rows:

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/vant47~naver-shopping-scraper/run-sync-get-dataset-items' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"searchTerms":["노트북"],"maxItems":20}'
```

Python with the official Apify client:

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("vant47/naver-shopping-scraper").call(
    run_input={"searchTerms": ["텀블러"], "maxItems": 20}
)
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row.get("recordType") == "PRODUCT":
        print(row["productId"], row["title"], row["price"])
```

JavaScript with the official client:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('vant47/naver-shopping-scraper').call({
  searchTerms: ['선크림'], maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
const products = items.filter(row => row.recordType === 'PRODUCT');
console.log(products.map(({ productId, title, price }) => ({ productId, title, price })));
```

For larger jobs, start asynchronously and paginate the completed dataset. Retrieve `SUMMARY` from the default key-value store. After a synchronous timeout, check the existing run before starting another.

### Limits and FAQ

**Does it read all Naver Shopping results?**

No. It reads public mobile shopping snapshots, typically up to 150 cards per term, sometimes fewer. It does not paginate the full shopping catalog.

**Can it fetch every seller's price or written reviews?**

No. Full mall-offer tables and review text are unavailable. A single-store card can provide one displayed offer. Unavailable extras incur no extra event charge.

**Why are brand, maker or category names empty?**

The cards do not consistently supply those names. Category IDs are retained. Missing names stay `null` and are never inferred from titles.

**Is price the checkout total?**

No. It is the card's product price before shipping. Coupons, membership, payment method and selected options can change the total. Check the linked page.

**Why fewer products than requested?**

Snapshot size, filters, duplicate removal and the spending limit can reduce output. `SUMMARY` explains source counts and failures. `maxItems` is an upper limit.

**Does newest sorting work?**

Listing dates are unavailable. `newest` reports that limit and retains relevance order. Other sorts operate within the snapshot.

**What happens on a refusal?**

The search receives a free note and partial summary; other inputs continue. Retries honor Retry-After. No challenge is solved and no account session is used.

**What is purchaseCount?**

Naver's positive displayed count, not an independently verified sales or revenue estimate. Missing or non-positive placeholders become `null`.

**Can I paste catalog links?**

Standalone catalog URLs return a free note. Use keywords or saved search links for collection. Output product links support manual checks.

**Can I schedule and export?**

Yes. Use Apify tasks, schedules, dataset exports, integrations and the API. Match product IDs across runs and retain observation times.

# Actor input Schema

## `searchTerms` (type: `array`):

Korean or English product searches, for example 무선 이어폰 or coffee. Reads the public mobile shopping-search snapshot. At most 100 searches.

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

Optional public Naver search URLs containing query=. Accepts URL strings or objects with url. Standalone catalog and category links return a free note because those pages are unavailable.

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

Price and review order apply within the returned snapshot. newest has no source date and returns a note with relevance order.

## `priceMin` (type: `integer`):

Keep snapshot products priced at least this amount. Not a full-catalog query.

## `priceMax` (type: `integer`):

Keep snapshot products priced at most this amount. Narrow bands can return no products.

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

Global unique product limit. A keyword normally exposes up to 150 public cards. Duplicates are saved and charged once per run.

## `includeOffers` (type: `boolean`):

For a single-store card, include its one displayed price, shipping and link at no extra charge. Catalog-wide mall offers are unavailable; offersComplete is false.

## `includeReviews` (type: `boolean`):

Review text is unavailable on this route. This option adds a free coverage note. Rating and reviewCount are included on every product when shown.

## `maxReviews` (type: `integer`):

Reserved for review text, currently unavailable. No reviews are collected or charged.

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

Datacenter proxy is sufficient on the tested search route. Failed requests retry with fresh sessions; automatic Korean residential fallback is used only when default datacenter requests fail. No account cookies.

## Actor input object example

```json
{
  "searchTerms": [
    "무선 이어폰"
  ],
  "startUrls": [],
  "sort": "relevance",
  "maxItems": 20,
  "includeOffers": false,
  "includeReviews": false,
  "maxReviews": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `products` (type: `string`):

No description

## `allFields` (type: `string`):

No description

## `summary` (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 = {
    "searchTerms": [
        "무선 이어폰"
    ],
    "startUrls": [],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("vant47/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 = {
    "searchTerms": ["무선 이어폰"],
    "startUrls": [],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("vant47/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 '{
  "searchTerms": [
    "무선 이어폰"
  ],
  "startUrls": [],
  "maxItems": 20
}' |
apify call vant47/naver-shopping-scraper --silent --output-dataset

```

## MCP server setup

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