# Naver Brand Store Product Details Scraper (`automation-lab/naver-brand-store-product-details`) Actor

Extract supplied Naver Brand Store product URLs into prices, immediate discounts, product-level stock, images, review totals, brand/model and delivery details for recurring selected-product snapshots.

- **URL**: https://apify.com/automation-lab/naver-brand-store-product-details.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.66 / 1,000 item extracteds

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 Brand Store Product Details Scraper

Extract **Naver Brand Store product details** from supplied product URLs into reusable snapshots of public prices, product-level stock, images, review totals, brand/model and delivery information. Designed for Korean ecommerce teams monitoring a selected assortment without repeating keyword discovery.

This Actor supports `brand.naver.com` only. It does not scrape SmartStore, individual SKU options, review text, seller contact details or price history. It is independent of and not affiliated with Naver.

### Who is it for?

Korean ecommerce pricing analysts and merchandising teams maintaining a known Brand Store assortment can collect repeatable snapshots for their own reports. For keyword discovery or option-level inventory, choose a different product.

### Why use it?

Maintain the same product watchlist across scheduled runs. Each product has a stable product ID and canonical URL so you can compare snapshots in your own spreadsheet or database. Public immediate discounts are separated from the listed price. Stock is explicitly product-level, not a promise that a particular size or color can be purchased.

### Getting started

1. Copy a public Brand Store product URL.
2. Add it to `productUrls`; do not supply store homepages or keyword searches.
3. Choose `maxItems` and run the Actor.
4. Inspect the Products dataset view and export JSON, CSV or Excel using Apify.
5. For recurring checks, schedule the same input and compare `productId` downstream.

```json
{
  "productUrls": [
    "https://brand.naver.com/lumena/products/13244298880",
    "https://brand.naver.com/pictory/products/4108300313"
  ],
  "maxItems": 2
}
```

### Input parameters

| Parameter | Behavior |
| --- | --- |
| `productUrls` | Required array of 1–100 HTTPS Brand Store product URLs. Query strings/fragments are removed and duplicate canonical URLs are requested once. All entries are validated, including entries beyond the limit. |
| `maxItems` | Global limit on unique supplied products requested in first appearance order. Default 10; range 1–100. Zero and unlimited are invalid. |

No proxy credentials or extra paid-service accounts are needed. Korean residential proxy routing is included and paid by the operator. There is no search, filter or discovery mode.

### Extracted data

| Fields | Meaning |
| --- | --- |
| `productId`, `url`, `storeSlug`, `storeName`, `name` | Public product identity and store display name |
| `currency`, `salePrice` | KRW and listed product price before immediate discount |
| `discountedPrice`, `discountPercent` | Public immediate discount; excludes personalized membership/coupon benefits |
| `stockQuantity`, `saleStatus`, `inStock` | Source-reported product-level quantity/status; `inStock` requires positive stock and `SALE` |
| `brand`, `model`, `category` | Public manufacturer/brand metadata and category path |
| `images` | Representative and additional public image URLs; image files are not downloaded |
| `reviewCount`, `averageRating` | Aggregate review totals and rating, not individual reviews |
| `deliveryFeeType`, `deliveryFee`, `deliveryCarrier`, `deliveryAttribute` | Public base shipping information, not a destination quote |
| `scrapedAt` | ISO timestamp of extraction |

Unavailable scalar fields are null. Missing image lists are empty arrays. Conditional shipping thresholds and destination surcharges are not modeled. The default dataset contains one row per successfully extracted unique product.

### Output example

A local public Lumena product snapshot returned the following values; values can change between runs:

```json
{
  "productId": "13244298880",
  "url": "https://brand.naver.com/lumena/products/13244298880",
  "storeSlug": "lumena",
  "name": "루메나 프리미엄 휴대용 무선 냉각선풍기 FAN JET ULTRA PLUS",
  "currency": "KRW",
  "salePrice": 74900,
  "discountedPrice": 59900,
  "discountPercent": 20,
  "stockQuantity": 267,
  "saleStatus": "SALE",
  "inStock": true,
  "brand": "루메나",
  "model": "FAN JET ULTRA PLUS",
  "reviewCount": 20790,
  "averageRating": 4.83,
  "deliveryFeeType": "FREE",
  "deliveryFee": 0,
  "deliveryCarrier": "한진택배"
}
```

### How much does it cost to extract Naver Brand Store product details?

A one-time `start` event and one `item` event per delivered product apply. Invalid inputs are rejected before the start event. Failed requests, retries and duplicate URLs have no separate item charge. A later failed product can leave previously delivered and charged rows in a failed run.

The start fee is **$0.012 per valid run**. Product event prices depend on your Apify Store spend tier:

| Tier | Per product |
| --- | ---: |
| FREE | $0.0031855 |
| BRONZE | $0.00277 |
| SILVER | $0.0021606 |
| GOLD / PLATINUM / DIAMOND | $0.001662 |

At BRONZE, estimated Actor event charges are $0.01477 for 1 product, $0.0397 for 10, and $0.289 for 100. Platform usage, taxes and adjustments can affect your final bill. Spend tiers reflect qualifying aggregate monthly Apify Store spend, not this Actor's private volume schedule. Infrastructure and proxy costs are paid by the operator; no off-platform payment is required.

### Limits and failure behavior

Up to three attempts per product use fresh Korean residential proxy sessions, with a 30-second request timeout. Products are processed sequentially. Blocked pages, malformed state and mismatched product IDs are errors, not successful empty snapshots. A deleted/unavailable product or exhausted retries fails the run. Any existing rows are partial output; inspect run status before treating an export as complete. The platform timeout and spending limit can also end collection before the input limit.

### Integrations

Send snapshots to Google Sheets for a selected-product price watchlist, or to a warehouse keyed by `productId` and `scrapedAt`. Use Apify schedules for recurring collection and webhooks to initiate downstream comparisons after successful completion. This Actor itself does not store historical comparisons or send price-change alerts.

### API usage

Use your own Apify token outside URLs where possible. Do not share credentials in input or logs.

```bash
curl -X POST -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  'https://api.apify.com/v2/acts/automation-lab~naver-brand-store-product-details/runs' \
  -d '{"productUrls":["https://brand.naver.com/lumena/products/13244298880"],"maxItems":1}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/naver-brand-store-product-details').call({
  productUrls: ['https://brand.naver.com/lumena/products/13244298880'], maxItems: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 10 });
console.log(items);
```

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/naver-brand-store-product-details').call(
    run_input={'productUrls': ['https://brand.naver.com/lumena/products/13244298880'], 'maxItems': 1})
print(client.dataset(run['defaultDatasetId']).list_items(limit=10).items)
```

### MCP setup

For Claude Code:

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

For Claude Desktop, Cursor, and VS Code, use the client's supported HTTP MCP configuration and Apify authentication:

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

Example prompt: “Extract these two Brand Store product URLs and compare their public immediate-discount prices. Do not interpret product-level stock as SKU stock.”

### Reading MCP results safely

Discover actual tool names and argument schemas with scoped `tools/list`; the selection also exposes run/data helpers, not just one tool. Consumer prompt recipe:

1. Invoke this Actor once with the supplied `productUrls` and `maxItems`. If using `call-actor`, choose `waitSecs=30` (allowed 0–45); configure the client request timeout above that wait plus transport margin, within a 120-second total deadline. Save the returned run ID, status and storage IDs; these are metadata, not rows.
2. If nonterminal, use `get-actor-run` for that **same run ID**, with 2/4/8-second backoff capped at 10 seconds. On client timeout, recover the known run's status instead of restarting. If the run ID is unknown, report uncertainty and do not blindly rerun. At the total deadline, report pending with the ID and stop polling. Report terminal failures honestly; any rows from them are partial, not complete successful results.
3. After success, use `get-dataset-items` with the returned `defaultDatasetId`, explicit `limit=20`, initial `offset=0`, and `fields` projecting `productId,url,name,currency,salePrice,discountedPrice,stockQuantity,saleStatus,inStock,scrapedAt` for this price comparison. Encode arguments as the discovered schema requires. Prefer untransformed JSON; continue at source `offset=20`, then 40, etc., using pagination metadata rather than filtered/transformed row counts.
4. Admit at most 100 source rows **and 64 KiB of serialized UTF-8 result content across all pages**, whichever comes first. Enforce the byte ceiling host-side before model injection, including oversized rows/pages: omit or summarize them with disclosure. If the client cannot intercept oversized responses, do not claim a hard byte guarantee or request unbounded data. Stop at exhaustion or budget and report admitted row count, continuation source offset and partial/truncated status. Keep full exports/downloads in Apify storage or downstream processing outside model context.

These are consumer context budgets, not Actor collection limits. They do not reduce collected fields or promise client-independent token savings.

### Data handling and responsible use

No AI model is used during extraction or to generate product values. The Actor requests public product pages through Apify's Korean residential proxy, emits only selected product fields, and does not collect seller contacts or reviewer identities. Product URLs are canonicalized to remove tracking queries. No cookies or sessions are stored for later runs.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed; diagnostic reports are retained for 30 days. Dataset and run-log retention follows your Apify account settings; delete the run storages in Apify when no longer needed. No operator-maintained product archive is created.

### Legality and responsible use

Use data responsibly under applicable laws and source terms. Public availability does not grant unlimited reuse rights. This Actor uses Apify's standard end-user terms and makes no affiliation or endorsement claim.

### FAQ and troubleshooting

**Does it support SmartStore or reviews?** No. SmartStore, SKU options and review text are outside this product contract.

**Why did a product fail?** It may have been removed, access-restricted or challenged by Naver. Verify the URL in a browser and inspect the failed run log. Existing output from a failed run is partial.

**Why is stock null or different from an option selector?** The field is source-reported product-level stock. Missing values stay null and can differ from individual option quantities.

**Can I monitor changes?** Schedule recurring snapshots and compare them downstream. The Actor does not create a history database or alert service.

### Related Actors and support

Use [Naver Shopping Product Scraper](https://apify.com/automation-lab/naver-shopping-product-scraper) for keyword discovery rather than supplied-product snapshots. For help, open an issue on this Actor's Apify Store Issues tab with a public product URL, input and run link. Do not include secrets.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/naver-brand-store-product-details/changelog.md

# Actor input Schema

## `productUrls` (type: `array`):

1–100 HTTPS URLs of the form https://brand.naver.com/{brand}/products/{id}. SmartStore and other hosts are rejected. Query strings and fragments are removed; duplicate canonical URLs produce one record, preserving first appearance order.

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

Global maximum number of unique supplied products to request, in input order after deduplication. Default 10; valid range 1–100. Zero and unlimited are not supported. A terminal upstream failure fails the run; previous rows remain partial output.

## Actor input object example

```json
{
  "productUrls": [
    "https://brand.naver.com/lumena/products/13244298880",
    "https://brand.naver.com/pictory/products/4108300313"
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Public product prices, availability, images, review totals and delivery details.

# 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 = {
    "productUrls": [
        "https://brand.naver.com/lumena/products/13244298880",
        "https://brand.naver.com/pictory/products/4108300313"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/naver-brand-store-product-details").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 = { "productUrls": [
        "https://brand.naver.com/lumena/products/13244298880",
        "https://brand.naver.com/pictory/products/4108300313",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/naver-brand-store-product-details").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 '{
  "productUrls": [
    "https://brand.naver.com/lumena/products/13244298880",
    "https://brand.naver.com/pictory/products/4108300313"
  ]
}' |
apify call automation-lab/naver-brand-store-product-details --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/naver-brand-store-product-details"
        }
    }
}
```

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/8HPI0GOuwuLMyDvob/builds/LOhusXTxln3bYMLiy/openapi.json