# Naver Search API — Shopping, Blog, News, Cafe & Trends (`highbrow_fame/naver-search-api`) Actor

Naver Shopping, blog, news, cafe, image, book and local search via Naver's official Open API, plus DataLab trends. Clean JSON with prices, malls, brands and categories. Bring your own free key.

- **URL**: https://apify.com/highbrow_fame/naver-search-api.md
- **Developed by:** [yestrue](https://apify.com/highbrow_fame) (community)
- **Categories:** E-commerce, Developer tools, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 result delivereds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Search API — Shopping, Blog, News, Cafe & Trends

Search Naver through its **official Search Open API**, with **your own free Client ID**. Get Naver Shopping products with lowest and highest price, mall, brand, maker and category path; blog posts, news, cafe posts, Knowledge iN questions, images, web documents, books, encyclopedia entries and local places; and DataLab trend series for search interest and shopping clicks. Every result comes back as one clean JSON row — no HTML tags, prices as numbers, rank included — ready for a spreadsheet, a database or an AI agent.

It is an API, not a scraper: no browser, no CAPTCHAs, no blocked pages. Your key, Naver's published quota, clean data.

**Start in a few minutes:**

1. Create your free Naver application and copy its **Client ID** and **Client Secret** (3 steps below; a one-time setup).
2. Paste both into the Actor, keep the prefilled search words (`무선 이어폰`, `텀블러`) or type your own — Korean or English.
3. Press **Start**. Seconds later the **Output** tab lists the products with prices, malls, brands and categories. Download JSON, CSV or Excel.

You pay per result delivered. A search word that finds nothing, a wrong input, a rejected key or a used-up daily quota cost nothing.

**Use it to:**

- Watch **prices and offers on Naver Shopping**: lowest and highest price, used or rental items filtered out, Naver Pay only, newest first or by price.
- Compare **brands, malls and categories** for a keyword: who sells it, under which brand, in which category path.
- Track what Korea is saying: **blog, cafe and news** hits for a brand or product, with summaries, dates and links.
- Find **books, places and encyclopedia entries**, or the images Naver shows for a keyword.
- See what is rising with **DataLab**: search interest for keyword groups since 2016, shopping click trends per category and per keyword since 2017.
- Feed an AI agent or a dashboard with Korean market data from the source Naver itself offers to developers.

### Get your free Naver Client ID (3 steps)

1. **Sign in at [developers.naver.com](https://developers.naver.com/)** with a Naver account (free to create) and choose **Application > Register Application** (애플리케이션 등록). The first time, Naver asks you to accept its terms and to verify your mobile phone number and enter a company name — a one-time step.
2. **Fill in the application**: any name, and under **API to use** (사용 API) add **Search** (검색); for the trend types also add **DataLab (Search Trends)** (데이터랩 검색어트렌드) and/or **DataLab (Shopping Insight)** (데이터랩 쇼핑인사이트). Under the non-login API environment (비로그인 오픈 API 서비스 환경) add a **WEB** setting with a web address, for example `http://localhost`. Click **Register** (등록하기).
3. **Copy the keys**: open **Application > My Applications** (내 애플리케이션), click your application, and on the **Overview** tab (개요) copy the **Client ID** and, after clicking **Show** (보기), the **Client Secret**.

Paste them into **Naver Client ID** and **Naver Client Secret**. They are stored as secret inputs, sent only to Naver's API in the request headers, and never written to the results or the log. Naver's Search API gives every application **25,000 calls a day** for free (DataLab: 1,000 a day); the quota counts per Client ID, so it is yours alone.

### What each search type returns

| Search type | What you get | Typical fields |
|---|---|---|
| `shop` Shopping | Products from Naver Shopping | `title`, `lprice`, `hprice` (KRW numbers), `mallName`, `brand`, `maker`, `category1`–`category4`, `categoryPath`, `productId`, `productGroup` (general / used / discontinued / upcoming), `productKind`, `link`, `image` |
| `blog` Blog | Naver blog posts | `title`, `description`, `link`, `bloggerName`, `bloggerLink`, `postDate` |
| `news` News | News articles | `title`, `description`, `link`, `originalLink`, `publishedAt` |
| `cafearticle` Cafe | Posts in public Naver Cafes | `title`, `description`, `link`, `cafeName`, `cafeUrl` |
| `kin` Knowledge iN | Questions on Naver's Q\&A | `title`, `description`, `link` |
| `image` Images | Images with size | `title`, `link`, `thumbnail`, `sizeWidth`, `sizeHeight` |
| `webkr` Web | Web documents | `title`, `description`, `link` |
| `doc` Documents | Academic and professional documents | `title`, `description`, `link` |
| `book` Books | Books with list and sale price | `title`, `author`, `publisher`, `price`, `discount`, `isbn`, `pubDate`, `link`, `image` |
| `encyc` Encyclopedia | Encyclopedia entries | `title`, `description`, `link`, `thumbnail` |
| `local` Local | Places and businesses (max 5 per search word) | `title`, `category`, `address`, `roadAddress`, `mapx`, `mapy`, `longitude`, `latitude`, `link` |
| `trend-search` | Search interest over time for keyword groups (DataLab) | `group`, `keywords`, `data` `[{ period, ratio }]`, `peakPeriod`, `peakRatio`, `lastRatio` |
| `trend-shopping-category` | Shopping click trend per category (Shopping Insight) | `group`, `categoryCodes`, `data`, `peakPeriod`, `peakRatio` |
| `trend-shopping-keyword` | Shopping click trend of keywords inside one category | `group`, `keywords`, `categoryCode`, `data`, `peakPeriod`, `peakRatio` |

Every search result row also has `searchType`, `query` (your search word), `rank` (1-based, in the order you chose), `totalResults` (how many matches Naver reports), `status` and `scrapedAt`. Trend rows have `searchType`, `group`, the period and `status` instead.

### How it works

1. You choose **What to search**, list your **Search words** (one per line) and how many results you want per word.
2. The Actor calls Naver's official Open API with your Client ID and Secret, page by page: up to 100 results per call, up to 10 calls per search word.
3. Each result is cleaned: the `<b>` tags Naver puts around matched words are removed, HTML entities are decoded, prices become numbers, empty values become `null`, dates become ISO dates, and shopping `productType` is split into a group and a kind.
4. The trend types send one DataLab request per run and return one row per keyword group or category, with the whole series in `data` and its peak and last value ready to read. Naver reports a **relative** ratio: the biggest value of the answer is 100. In the dataset API, `unwind=data&flatten=data` turns a series into one row per data point.

If Naver rejects your key or the quota is used up, the run stops at once with one clear message in the status line and one free record in the dataset — what was already delivered is kept.

### Limits (set by Naver)

- **1,000 results per search word.** Naver lets an application page through the first 1,000 results of a search (100 per call). Need more? Search with more specific words. Local search returns at most 5 places per search word.
- **25,000 Search API calls a day per Client ID** (DataLab: 1,000 a day). A 1,000-result search word uses 10 calls. The quota resets every day.
- **Shopping search returns the list data above.** Naver's Search API does not include reviews, seller offer lists, stock or option details.
- Web, document and encyclopedia search have no sort order; local search has two (relevance, most reviewed).

### Input

| Field | What it does |
|---|---|
| `clientId`, `clientSecret` | Your Naver application's keys (secret inputs). |
| `searchType` | What to search: `shop` (default), `blog`, `news`, `cafearticle`, `kin`, `image`, `webkr`, `doc`, `book`, `encyc`, `local` or a trend type. |
| `queries` | Search words, one per line, Korean or English. For trend types, one group per line: `Group name=word1,word2`. |
| `maxResultsPerQuery` | Results per search word, 1–1,000 (default 100; local: up to 5). |
| `sort` | `sim` relevance (default), `date` newest first, `asc` / `dsc` price low→high / high→low (shopping), `point` rating (Knowledge iN), `comment` most reviewed (local). |
| `excludeUsed`, `excludeRental`, `excludeCrossBorder`, `naverPayOnly` | Shopping filters Naver applies itself: leave out used items, rentals, overseas direct purchase; keep only Naver Pay products. |
| `imageSize` | Image search: `all`, `large`, `medium`, `small`. |
| `shoppingCategory` | Trend type "shopping keyword": the `cat_id` number of a Naver Shopping category, for example `50000000`. |
| `trendStartDate`, `trendEndDate`, `trendTimeUnit` | Trend period (`yyyy-mm-dd`; default: the last year up to yesterday) and `date` / `week` (default) / `month`. |
| `trendDevice`, `trendGender`, `trendAges` | Trend filters: `pc` / `mo`, `m` / `f`, age codes (see the input form). |
| `maxConcurrency` | Search words worked on at the same time (default 2). |

### Output

An example shopping row (the values are illustrative):

```json
{
  "searchType": "shop",
  "query": "무선 이어폰",
  "rank": 2,
  "title": "삼성전자 갤럭시 버즈 무선 이어폰 5.3 \"프로\" 케이스 & 파우치",
  "productId": "82452688468",
  "lprice": 29900,
  "hprice": 159000,
  "currency": "KRW",
  "mallName": "네이버",
  "brand": "삼성전자",
  "maker": "삼성전자",
  "category1": "디지털/가전",
  "category2": "음향가전",
  "category3": "이어폰",
  "category4": "블루투스이어폰",
  "categoryPath": "디지털/가전 > 음향가전 > 이어폰 > 블루투스이어폰",
  "productType": 1,
  "productGroup": "general",
  "productKind": "price-comparison",
  "link": "https://search.shopping.naver.com/gate.nhn?id=82452688468",
  "image": "https://shopping-phinf.pstatic.net/main_8245268/82452688468.jpg",
  "totalResults": 1234567,
  "status": "OK",
  "scrapedAt": "2026-10-31T12:00:00.000Z"
}
```

An example trend row (search interest for one keyword group):

```json
{
  "searchType": "trend-search",
  "group": "한글",
  "keywords": ["한글", "korean"],
  "startDate": "2017-01-01",
  "endDate": "2017-04-30",
  "timeUnit": "month",
  "points": 4,
  "peakPeriod": "2017-03-01",
  "peakRatio": 100,
  "lastPeriod": "2017-04-01",
  "lastRatio": 85.32,
  "data": [
    { "period": "2017-01-01", "ratio": 47 },
    { "period": "2017-02-01", "ratio": 53.23 },
    { "period": "2017-03-01", "ratio": 100 },
    { "period": "2017-04-01", "ratio": 85.32 }
  ],
  "status": "OK"
}
```

A search word that gave nothing is one free record with `status` `NO_RESULTS` (or `FAILED`, `PARTIAL`, `INVALID_INPUT`) and the reason in `error`.

### FAQ

**Is this an official Naver product?** The data comes from Naver's official Search Open API and DataLab APIs, called with your own application's keys. The Actor itself is an independent tool and is not made by, or affiliated with, Naver. Your use of Naver's APIs is subject to Naver's API terms, which you accept when you register your application.

**Why do I need my own Client ID?** Naver issues API access per application: the 25,000 daily calls belong to the Client ID that makes them. With your own key the quota is yours, the usage shows in your own Naver developer console, and nobody shares a limit with you.

**What does the Naver side cost?** Nothing within the free quota (25,000 Search API calls a day, 1,000 DataLab calls a day). You pay only for the results this Actor delivers.

**My run says "Naver rejected your credentials". What now?** Check three things: the Client ID and Client Secret are copied exactly (no spaces); the application on developers.naver.com has **Search** added under its API settings tab (and DataLab for the trend types); the application is the one you copied the keys from. Then run again.

**The status says HTTP 429.** Naver's daily call quota for your Client ID is used up (or calls came too fast). It resets every day — run again later, or ask for fewer results per search word. The results delivered before the stop are kept.

**Can I get product reviews, seller offers or stock?** Not from this API: Naver's Search API returns the list data in the table above. It is the right tool for prices, malls, brands, categories, ranks, blog, cafe and news coverage, and trends.

**Why are `lprice` or `hprice` empty?** Naver sends 0 or an empty value when it has no price information; the Actor turns that into `null` instead of a misleading 0. For a product without price comparison, `lprice` is the product's own price.

**Which language are the results in?** Korean, as Naver sends them. Search words can be Korean or English.

**Can I schedule it?** Yes — use Apify schedules or the API to run the same search words daily and compare prices or ranks over time.

**Like it?** A short review on the Store page helps other people find this Actor. Something missing or broken? Tell us on the Issues tab — we read every one.

**Ready? Get your free Client ID, paste it in, and press Start — your first Naver Shopping table is minutes away.**

# Actor input Schema

## `clientId` (type: `string`):

Required. The Client ID of your own free Naver application: developers.naver.com > Application > Register Application, add the Search API (and DataLab for the trend types), then copy it from the app's Overview tab. Stored as a secret; it is sent only to Naver's API and never written to the results or the log.

## `clientSecret` (type: `string`):

Required. The Client Secret of the same Naver application (Overview tab > Client Secret > show). Stored as a secret; never written to the results or the log.

## `searchType` (type: `string`):

Which part of Naver to search. Shopping returns products with prices, malls, brands and categories; the other search types return titles, summaries and links. The three trend types return a time series from Naver DataLab (see the trend options below).

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

One search per line, in Korean or English (for example 무선 이어폰 or laptop). Duplicates are searched once. For the three trend types each line is one group instead: 'Group name=word1,word2' (or just 'word1,word2'); for shopping category trends the words are category codes such as 50000000; for shopping keyword trends it is one keyword per line.

## `maxResultsPerQuery` (type: `integer`):

How many results to collect for each search word. Naver shows at most the first 1,000 results of a search (100 per call, so up to 10 calls), and local places at most 5. Ignored by the trend types.

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

Relevance is Naver's default. Newest first works for shopping, blog, news, cafe, Knowledge iN, image and book search; the price orders are for shopping only; highest rated is for Knowledge iN only; most reviewed is for local places only. A choice that does not exist for the search type is replaced by relevance (the log says so); web, document and encyclopedia search have no sort order.

## `excludeUsed` (type: `boolean`):

Shopping search only. Leaves out second-hand products (Naver's exclude=used).

## `excludeRental` (type: `boolean`):

Shopping search only. Leaves out rental products (Naver's exclude=rental).

## `excludeCrossBorder` (type: `boolean`):

Shopping search only. Leaves out overseas direct-purchase and purchasing-agent products (Naver's exclude=cbshop).

## `naverPayOnly` (type: `boolean`):

Shopping search only. Keeps only products that work with Naver Pay (Naver's filter=naverpay).

## `imageSize` (type: `string`):

Image search only.

## `shoppingCategory` (type: `string`):

Only for 'shopping keyword clicks in a category'. The number after cat_id= in the address of a Naver Shopping category page, for example 50000000.

## `trendStartDate` (type: `string`):

yyyy-mm-dd. Empty means one year before the end date. Search trends start 2016-01-01, shopping trends 2017-08-01.

## `trendEndDate` (type: `string`):

yyyy-mm-dd. Empty means yesterday.

## `trendTimeUnit` (type: `string`):

One data point per day, week or month.

## `trendDevice` (type: `string`):

Count searches or clicks from all devices, from PC only or from mobile only.

## `trendGender` (type: `string`):

Count all users, only men or only women.

## `trendAges` (type: `array`):

Optional, one code per line; empty means all ages. Search trends: 1 (0-12), 2 (13-18), 3 (19-24), 4 (25-29), 5 (30-34), 6 (35-39), 7 (40-44), 8 (45-49), 9 (50-54), 10 (55-59), 11 (60+). Shopping trends: 10 (10-19), 20 (20-29), 30 (30-39), 40 (40-49), 50 (50-59), 60 (60+).

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

How many search words are worked on at the same time. Calls are also spaced out, so the default is safe for Naver's limits.

## Actor input object example

```json
{
  "searchType": "shop",
  "queries": [
    "무선 이어폰",
    "텀블러"
  ],
  "maxResultsPerQuery": 100,
  "sort": "sim",
  "excludeUsed": false,
  "excludeRental": false,
  "excludeCrossBorder": false,
  "naverPayOnly": false,
  "imageSize": "all",
  "trendTimeUnit": "week",
  "trendDevice": "all",
  "trendGender": "all",
  "maxConcurrency": 2
}
```

# Actor output Schema

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

Every result as a JSON record, with a status for each search word.

## `resultsCsv` (type: `string`):

The same records as CSV, for a spreadsheet.

# 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 = {
    "queries": [
        "무선 이어폰",
        "텀블러"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("highbrow_fame/naver-search-api").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 = { "queries": [
        "무선 이어폰",
        "텀블러",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("highbrow_fame/naver-search-api").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 '{
  "queries": [
    "무선 이어폰",
    "텀블러"
  ]
}' |
apify call highbrow_fame/naver-search-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,highbrow_fame/naver-search-api"
        }
    }
}
```

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/vHa1CVNwi6TipiJVq/builds/wlCTw1GIBiUiERQmm/openapi.json