# Naver Shopping Best Seller Ranking, Keyword Trend & Brand Chart (`s-r/naver-shopping-rank`) Actor

Get Naver Shopping best seller charts for Korea: top products by views and purchases, trending search keywords with rank movement, and brand rankings. Filter by category, week or day, and by age and gender segment. Korean titles, KRW prices, seller names and ratings.

- **URL**: https://apify.com/s-r/naver-shopping-rank.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 chart rows

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 Best Seller Ranking, Keyword Trend & Brand Chart

Naver is where South Korea shops. This Actor reads Naver Shopping's own published
charts and hands them back as clean rows: the products Koreans viewed and bought
most, the search keywords that are climbing, the brands they are looking for, and
the themed collections Naver builds every day. Korean titles are kept exactly as
Naver writes them, prices are in won, and every row carries the date Naver
computed it.

It is ranking and trend data. Read the **What this cannot do** section before you
buy, because it is short and it matters.

### What you get

**Product charts.** Up to 100 best sellers per run, ranked either by how many
people viewed the product or by how many bought it, daily or weekly. Each row
carries the Naver product id, the Korean title, list price and sale price in won,
the discount percent, the star rating, the review count, the store selling it and
that store's link, the delivery charge, and whether the listing carries Naver's
arrival guarantee.

**Eleven categories.** Everything combined, or one of fashion clothing, fashion
accessories, cosmetics and beauty, digital and appliances, furniture and interior,
maternity and baby, food, sports and leisure, life and health, or leisure and
convenience.

**Twelve audience segments.** This is the part you will not find elsewhere. The
same chart can be ranked for men in their twenties, women over fifty, or any of
the ten other age-and-gender bands Naver tracks, as well as everyone at once. The
top-selling product for men in their twenties is usually nothing like the
top-selling product overall, and each segment is one run.

**Trending keyword charts.** Twenty rising Korean shopping searches per chart,
with the rank, Naver's own movement label (NEW, UP, SOAR, DOWN, STABLE), the full
category path Naver files the keyword under, and related search terms. Three
different orderings: most searched, rising fastest, and newly charting.

**Keyword history back to February.** The newly-charting keyword chart has roughly
seven months of weekly snapshots and eight monthly ones. Ask for a past date and
you get that week's chart. Ask for a date Naver does not hold and the run tells
you so, and names how many dates it does hold, instead of handing back an empty
sheet.

**Brand charts.** The twenty brands Koreans search for most, on three separate
charts, with related search terms for each brand.

**The products behind a keyword or a brand.** Turn on one checkbox and every
keyword or brand entry is expanded into its top twenty products, so a single run
turns twenty trending searches into four hundred ranked, priced products.

**Today's themed picks and the four vertical lists.** Naver's daily curated
collections, each with its Korean theme name and the copy Naver wrote for it, plus
the fashion town, best deals, arrival-guaranteed and shopping-live top twelves.

### What this cannot do

Three limits, stated plainly, because a product sold without them would be sold
dishonestly.

**It is charts, not search.** There is no way to type in an arbitrary keyword or a
product code and get matching listings. The keyword charts cover keywords that are
already trending; the product charts cover whole categories. If your question is
"find every Naver listing for this SKU", this Actor is the wrong tool and no
amount of configuration will change that.

**The prices are chart prices, not checkout prices.** Every row carries
`data_date`, and on the ranking charts that date is one or two days behind. Some
surfaces are labelled with the current Korean date, but on every product that
appears in both a dated chart and a current-dated surface the price was identical,
so the fresher label has not been shown to mean a fresher number. Treat every
price here as the price Naver charted, not the price at the till. If you need a
live checkout price, take the product URL from a row and check it yourself.

**Review counts stop at 99,999.** Naver does not print an exact figure above that;
it prints `99,999+`. Rather than hand you 99,999 and let you believe it is exact,
those rows carry an empty `review_count`, the raw string in
`review_count_display`, and `review_count_capped` set to true. Six of ninety-nine
rows on the all-category chart were capped when this was measured, so it is not a
rare edge case.

One more thing worth knowing rather than discovering: `rank_change_reported` is
Naver's own movement number and it does not survive arithmetic. Checked keyword by
keyword against the immediately preceding chart on Naver's own list of dates, four
of fifteen agreed and eleven did not, including a keyword that climbed from second
to first and reported no movement at all. It is passed through unchanged because
substituting our own figure under Naver's name would be worse. Read it as
direction, not as a measurement, and compute your own movement from two dated runs
if you need it exact.

### Reading the output

Each row carries `row_type` (product, keyword or brand) and `source`, which says
which chart produced it. Columns are not padded: a chart that does not carry
review data produces rows with no review columns at all, rather than rows with
empty ones, because an empty column reads as a fact about the product when it is
really a fact about the chart. Check `source` before assuming a column exists.

The run summary in the key-value store separates the outcomes that look identical
in an empty dataset. It says whether the request was refused before it was sent
(and why), whether Naver declined to serve the chart, or whether Naver served a
valid chart that happens to be empty today. It also reports the dates the data was
computed, how many review counts were capped, and how many rows Naver marked as
paid placement.

### Who this is for

Korean market analysts tracking what is selling and for whom. Brands watching
their own rank against competitors week by week. Sellers hunting product ideas by
reading what is climbing in their category. Trend researchers who want Korean
demand data segmented by age and gender, which is hard to get anywhere else.
Agencies building Korea market reports who need the chart, the date it was
computed, and an honest note on what the number means.

### Notes

Prices are in Korean won. Korean text is passed through exactly as published, not
transliterated or translated. Charts refresh daily; the same run tomorrow gives a
different chart, and storing yesterday's run is how you build a movement series.

# Actor input Schema

## `chart` (type: `string`):

Which Naver Shopping chart to read. Products = best-selling and most-viewed products. Keywords = trending shopping searches. Brands = the brand ranking. Today's items = themed picks carrying the current Korean date. Verticals = the four themed top-12 lists.

## `categoryId` (type: `string`):

Naver's top-level shopping category. 'A' is every category combined. Leisure and convenience has a product chart but no keyword or brand chart. Ignored for today's items and verticals.

## `ranking` (type: `string`):

How the chart is ordered. Products take mostViewed or mostBought. Keywords and brands take popular or rising, keywords also take new, brands also take mini. A value that does not belong to the chosen chart is refused with the list that does.

## `period` (type: `string`):

The window Naver aggregated over. The product chart carries daily and weekly only; it accepts monthly and answers with an empty list, so monthly is refused here rather than passed on.

## `ageType` (type: `string`):

Rank the chart for one age and gender segment instead of everyone. WOMEN\_ALL and MEN\_ALL work on the keyword and brand charts; on the product chart they return nothing, so they are refused there.

## `date` (type: `string`):

Read an older keyword chart, as YYYY-MM-DD. Only the keyword chart has history, and only on dates Naver holds; a date it does not hold is reported as such instead of returned empty. The product and brand charts ignore this parameter and return today, so it is refused for them.

## `includeProducts` (type: `boolean`):

For the keyword and brand charts, also read the products behind every chart entry. Adds up to 20 products per entry and one extra request each, so a 20-entry chart becomes roughly 420 rows.

## `verticals` (type: `array`):

Which themed lists to read when the chart is 'verticals'. Each serves 12 products. These rows carry no review data, no seller and no date, because Naver does not put those on this surface.

## `gender` (type: `string`):

Whose fashion town and best deal lists to read. Naver does not reject an unrecognised value, it quietly returns the women's list, so anything other than F or M is refused here.

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

Stop after this many rows. The product chart serves between 93 and 100 rows, the keyword and brand charts 20, each vertical 12.

## Actor input object example

```json
{
  "chart": "products",
  "categoryId": "A",
  "ranking": "mostViewed",
  "period": "DAILY",
  "ageType": "ALL",
  "date": "",
  "includeProducts": false,
  "verticals": [
    "fashiontown",
    "bestdeal",
    "logistics",
    "shoppinglive"
  ],
  "gender": "F",
  "maxItems": 100
}
```

# Actor output Schema

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

One row per chart entry.

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

Row count, the date the data was computed, and whether a run with no rows was refused, asked something the API answers misleadingly, or handed back a chart Naver served empty.

# 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 = {
    "chart": "products",
    "categoryId": "A",
    "ranking": "mostViewed",
    "period": "DAILY",
    "ageType": "ALL",
    "date": "",
    "includeProducts": false,
    "verticals": [
        "fashiontown",
        "bestdeal",
        "logistics",
        "shoppinglive"
    ],
    "gender": "F",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/naver-shopping-rank").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 = {
    "chart": "products",
    "categoryId": "A",
    "ranking": "mostViewed",
    "period": "DAILY",
    "ageType": "ALL",
    "date": "",
    "includeProducts": False,
    "verticals": [
        "fashiontown",
        "bestdeal",
        "logistics",
        "shoppinglive",
    ],
    "gender": "F",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/naver-shopping-rank").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 '{
  "chart": "products",
  "categoryId": "A",
  "ranking": "mostViewed",
  "period": "DAILY",
  "ageType": "ALL",
  "date": "",
  "includeProducts": false,
  "verticals": [
    "fashiontown",
    "bestdeal",
    "logistics",
    "shoppinglive"
  ],
  "gender": "F",
  "maxItems": 100
}' |
apify call s-r/naver-shopping-rank --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/naver-shopping-rank"
        }
    }
}
```

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/pDVQOKUxtKZHe88da/builds/YJBaHRTFJsIOXbRaG/openapi.json