# Naver Brand Store Scraper | Prices, Stock & Delivery (`apivault_labs/naver-smartstore-source-probe`) Actor

Collect known public Naver product URLs with sale/discount prices, source stock, delivery fees and review aggregates. Batch limits, filters, selected fields and continuation. Korean proxy required in cloud; SKU variants unavailable.

- **URL**: https://apify.com/apivault_labs/naver-smartstore-source-probe.md
- **Developed by:** [Apivault Labs](https://apify.com/apivault_labs) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 useful naver products

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Scraper — Prices, Stock & Delivery

![Naver product data illustration](https://raw.githubusercontent.com/apivault-labs/apivault-labs/82fc02ecf136e242d028f7094ecd50725ac3628a/assets/naver-product-data/cover-v2.png)

*Illustration only: example products and prices in the artwork are not live results. Delivery ETA is not extracted.*

Collect structured product cards from **known public Naver Brand Store URLs**: public sale and discount prices in KRW, exposed product stock, delivery fees, brand/store metadata and review aggregates. Use the results for price checks, inventory observations and compact catalog exports.

This is an **owner-only private candidate awaiting review**, not a published Store product. It supports supplied product links; it does not discover an entire store, search Naver Shopping, or promise access to every SmartStore merchant. Login-restricted pages remain errors. Individual SKU variants are currently unavailable.

### Start with a small real batch

```json
{
  "productUrls": [
    "https://brand.naver.com/nestlestore/products/10503912668",
    "https://brand.naver.com/nestlestore/products/13398080706",
    "https://brand.naver.com/locknlock/products/12639693708",
    "https://brand.naver.com/philips/products/13176919028"
  ],
  "transport": "korean_proxy",
  "maxItems": 4,
  "maxRequests": 8
}
```

[Open the private Actor](https://console.apify.com/actors/fx3vXGhGwjudk0OlY/input). The verified cloud route uses **Apify residential proxy in Korea**, requiring access in your Apify account. `direct` is an optional mode that worked locally but returned429 from tested datacenter IPs. No Naver login, merchant API key, or CAPTCHA solving is used. A SmartStore link can redirect to login while an actual public Brand Store link is accessible; a matching Brand Store hostname is not guaranteed to exist for every merchant.

### Useful scenarios

| Goal | Settings beyond productUrls |
|---|---|
| Price, stock and shipping snapshot | Default full output |
| Only known available inventory | `"availabilityFilter": "in_stock"` |
| Compact price CSV | `"outputFields": ["availability", "stockQuantity"]` |
| Products at or below50,000KRW | `"maxPrice": 50000` |
| Process a list in small chunks | `"maxItems": 2`, then use continuation input |

These five distinct scenarios are prepared as owner-only saved tasks on the [Actor Tasks tab](https://console.apify.com/actors/fx3vXGhGwjudk0OlY/tasks). Private tasks are not published templates. Inputs can be changed to your own publicly accessible product links. Price and stock observations are snapshots, not a stock reservation or checkout quote.

### Fields and their meaning

| Field | What you receive |
|---|---|
| productId / productUrl / sourceUrl | Matched channel product ID, canonical input link and page fetched |
| name / storeName / brand / imageUrl | Public source metadata, when exposed |
| price | Public discounted sale price when supplied; otherwise sale price |
| salePrice / discountedPrice | Separate list and discounted values; a genuine zero is preserved |
| currency / currencySource | KRW based on Naver domestic-store convention, with this basis explicit |
| availability / stockQuantity | Source sale state and exposed product-level inventory; unknown remains null |
| hasOptions / variants | Options flag when exposed; individual SKU combinations remain null |
| delivery | Exposed fee type, base fee, extra area fee, carrier and methods; no ETA |
| reviewCount / rating | Aggregate counts and average rating, not review text |
| scrapedAt / provenance | Timestamp and source state used |

Example: a previously observed Nestlé card had `price: 69900`, `salePrice: 89900`, `currency: "KRW"`, positive product stock and `delivery.baseFee: 0`. Values may change. Unknown stock is not zero, and unknown availability is not sold out. A product's aggregate stock does not represent stock for each size/color/SKU. Member coupons, personalized offers, destination surcharges and checkout eligibility can differ.

Download Dataset results as JSON, CSV or Excel using Apify's export controls. Nested delivery/source objects are best consumed as JSON; `outputFields` supports compact exports. `productId`, `productUrl`, `name`, `price` and `currency` are always included, even when choosing fields.

### Batch size, filters and continuation

| Input | Default | Bounds / behavior |
|---|---:|---|
| productUrls | Required | 1–10,000 supplied links; numeric product IDs deduplicate across mobile, tracking and host aliases |
| maxItems | 100 | 1–1,000 useful delivered products per run |
| maxRequests | 100 | 1–1,000 product fetch attempts; redirects can add HTTP calls |
| startOffset | 0 | Offset in the deduplicated ordered URL list |
| maxRunSeconds | 120 | 30–1,800seconds; time is reserved for an in-flight request |
| requestDelayMs | 500 | 250–10,000ms between attempts; collection is sequential |
| minPrice / maxPrice | Unset | Inclusive public price bounds in KRW |
| availabilityFilter | all | all, in_stock, out_of_stock; unknown passes only all |
| outputFields | All | Supported field names from the table above |
| excludeProductIds | Empty | Skip up to10,000 known IDs before source requests |

The limits support large supplied lists. They do not imply that1,000distinct products have been collected in a live benchmark. Local bulk contract tests use synthetic responses; cloud source coverage and economics are recorded separately.

After a bounded run, open the key-value record **CONTINUATION** and copy `resumeInput` into the next run. It contains the canonical list, matching settings and `startOffset`. A completed list has `resumeInput: null`. Keep the same ordered list; `inputFingerprint` helps identify accidental changes. `CHECKPOINT` contains the offset and current run's delivered IDs.

After429, the failed product remains at `nextOffset` so it is not silently lost. `remaining` includes that retryable item; `skipped` counts only products not attempted. Wait for the source to recover before manually continuing; the Actor never retries429 or rotates through retries automatically. For a crashed run, reconcile its Dataset before using a saved checkpoint because data written since the last checkpoint can otherwise repeat. Add already delivered IDs to `excludeProductIds` if needed.

### Errors and partial results

Only an identity-matched product with name and valid public price becomes a result. Error/challenge pages, login redirects, unrelated recommendations, source errors and filtered items are not exported as product rows. Redirects remain on allowed Naver product hosts, preserve the ID and stop after three responses. Unknown input fields and invalid URLs are rejected before product requests.

`SUMMARY` reports attempted, delivered, filtered, excluded, failed and skipped counts, stop reason, next offset and input fingerprint. `OBSERVATIONS` records sanitized source diagnostics without raw HTML, cookies or proxy credentials. `ERRORS` identifies failed offsets. An all-failed source run fails visibly. Partial success retains valid products and exposes errors and continuation. A successful empty filtered/excluded batch is a valid zero-result outcome.

### Cost and tariff status

**Owner-approved private tariff:** $1 per1,000 useful delivered products on the Free tier and $0.80 per1,000 on paid plans. There is no separate Actor startup fee. Apify compute/storage/transfer and residential proxy are paid separately by the user. The Actor remains private until the exact candidate is approved for publication.

Earlier small private probes measured roughly $0.54–0.61 in platform resources per1,000 useful rows by extrapolation, including residential traffic. This is a small-sample estimate, not a bulk guarantee, invoice or fixed per-product resource price. Failed requests can consume compute/proxy resources even when no product result is delivered. A PPE maximum charge caps Actor event fees, not all separate platform/proxy spending. Use request/time limits as well.

The result path is prepared for Apify SDK useful-result accounting: duplicates, exclusions and filters are handled before pushing data; zero accepted charges do not count as delivery or advance the offset. Paid live billing/cap QA is required before the candidate review.

### API, Python and n8n

Use [Apify's official Python client](https://docs.apify.com/api/client/python) or [JavaScript client](https://docs.apify.com/api/client/js). The Actor ID is `fx3vXGhGwjudk0OlY`; during private QA specify the candidate build tag `naver-mvp-20261022`.

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("fx3vXGhGwjudk0OlY").call(
    run_input={
        "productUrls": ["https://brand.naver.com/philips/products/13176919028"],
        "maxItems": 1,
        "transport": "korean_proxy"
    },
    build="naver-mvp-20261022"
)
for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product)
```

In n8n, use an HTTP Request or the generic Apify integration to start this Actor with the same JSON input, wait for completion, then read `defaultDatasetId`. [Apify integration guide](https://docs.apify.com/platform/integrations/n8n). A dedicated API Vault Naver community node/Python package is not verified or advertised. Private repository source is not an integration download. This candidate is not exposed as a custom MCP server; an MCP-capable client can use an authorized Apify API integration without bypassing private Actor access.

### FAQ and current limits

**Does it scrape every SmartStore?** No. Brand Store public cards are the proven route. Login-restricted SmartStore links remain errors; the supported URL pattern alone does not prove source access.

**Are SKU prices, sizes and per-option stock included?** No. Public detail API and fresh browser probes did not establish access to option combinations. `variants` remains null; the Actor is a core-card collector, not a complete replacement for competing full-detail scrapers.

**Does it search or crawl an entire store?** No. Supply product links. Continuation processes that input list; it is not discovery or source catalog pagination.

**Are stock and delivery guaranteed?** No. They describe exposed source state at collection time. Unknown fields stay null. Delivery ETA is not extracted.

**When will it be public?** After exact candidate owner review, paid billing QA and publishing prerequisites. Private preparation does not bypass those gates.

# Changelog

This Actor's version history is a separate document: https://apify.com/apivault_labs/naver-smartstore-source-probe/changelog.md

# Actor input Schema

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

Known public Brand Store or accessible SmartStore product URLs. No store discovery. Repeated IDs/mobile/tracking aliases deduplicate before requests.

## `transport` (type: `string`):

Korean residential proxy access is required by the verified cloud route. Proxy/compute are charged separately. Direct datacenter access can return429.

## `availabilityFilter` (type: `string`):

Unknown availability passes only all.

## `minPrice` (type: `number`):

Minimum public price (KRW); filters apply to source public prices, before result delivery.

## `maxPrice` (type: `number`):

Maximum public price (KRW); filters apply to source public prices, before result delivery.

## `outputFields` (type: `array`):

Empty returns all fields. productId/productUrl/name/price/currency are always included.

## `excludeProductIds` (type: `array`):

Skip these IDs without making source requests. Useful when reconciling a crash with its Dataset.

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

Maximum delivered products. Allowed range 1..1000. Request caps count product fetch attempts; redirects may add HTTP requests.

## `maxRequests` (type: `integer`):

Maximum source product requests. Allowed range 1..1000. Request caps count product fetch attempts; redirects may add HTTP requests.

## `startOffset` (type: `integer`):

Start offset in deduplicated list. Allowed range 0..10000. Request caps count product fetch attempts; redirects may add HTTP requests.

## `maxRunSeconds` (type: `integer`):

Collection time budget (seconds). Allowed range 30..1800. Request caps count product fetch attempts; redirects may add HTTP requests.

## `requestDelayMs` (type: `integer`):

Delay between product requests (milliseconds). Allowed range 250..10000. Request caps count product fetch attempts; redirects may add HTTP requests.

## Actor input object example

```json
{
  "productUrls": [
    "https://brand.naver.com/nestlestore/products/10503912668",
    "https://brand.naver.com/nestlestore/products/13398080706",
    "https://brand.naver.com/locknlock/products/12639693708",
    "https://brand.naver.com/philips/products/13176919028"
  ],
  "transport": "korean_proxy",
  "availabilityFilter": "all",
  "outputFields": [],
  "excludeProductIds": [],
  "maxItems": 100,
  "maxRequests": 100,
  "startOffset": 0,
  "maxRunSeconds": 120,
  "requestDelayMs": 500
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

## `checkpoint` (type: `string`):

No description

## `continuation` (type: `string`):

No description

## `errors` (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 = {
    "productUrls": [
        "https://brand.naver.com/nestlestore/products/10503912668",
        "https://brand.naver.com/nestlestore/products/13398080706",
        "https://brand.naver.com/locknlock/products/12639693708",
        "https://brand.naver.com/philips/products/13176919028"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apivault_labs/naver-smartstore-source-probe").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/nestlestore/products/10503912668",
        "https://brand.naver.com/nestlestore/products/13398080706",
        "https://brand.naver.com/locknlock/products/12639693708",
        "https://brand.naver.com/philips/products/13176919028",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("apivault_labs/naver-smartstore-source-probe").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/nestlestore/products/10503912668",
    "https://brand.naver.com/nestlestore/products/13398080706",
    "https://brand.naver.com/locknlock/products/12639693708",
    "https://brand.naver.com/philips/products/13176919028"
  ]
}' |
apify call apivault_labs/naver-smartstore-source-probe --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apivault_labs/naver-smartstore-source-probe"
        }
    }
}
```

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/fx3vXGhGwjudk0OlY/builds/mrJTsOeikPcALkjaK/openapi.json