# Naver Open Search API — Web Blog News Cafe Image (`khadinakbar/search-naver-open-api`) Actor

Query Naver Search via official NAVER API HUB for web, blog, news, cafe, image, Knowledge iN, encyclopedia, and local results. Bring your own Client ID/Secret. Cookieless HTTP, MCP-ready. Not for shopping/book/doc (sunset).

- **URL**: https://apify.com/khadinakbar/search-naver-open-api.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** SEO tools, AI, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 naver search results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Open Search API — Web, Blog, News, Cafe, Image

Query **Naver Search** through the official **NAVER API HUB** and get one clean dataset row per result. Built for Korean SEO teams, brand monitors, and AI agents that need structured blog, news, web, cafe, image, Knowledge iN, encyclopedia, or local results without browser scraping. Runs on Apify with API, schedule, and MCP access.

### Best fit

This Actor is designed for teams that already hold NAVER API HUB credentials and want official Search JSON for Korean keywords. It works well for brand monitoring, content research, and agent tool calls that need a bounded, BYOK Open API path.

**Constructive routing:** start with a small `maxResults` sample here, then continue with [Naver Product Shopping Scraper](https://apify.com/khadinakbar/naver-product-shopping-scraper) when you need shopping product cards, or pair it with [Naver Map Scraper](https://apify.com/khadinakbar/naver-map-scraper) for place phones and hours. For multi-country Google SERP blocks, use [Google SERP All-in-One Scraper](https://apify.com/khadinakbar/google-serp-all-in-one-scraper).

Supported verticals: blog, news, web, cafe, image, kin, encyclopedia, local, plus adult and errata helpers. Shop, book, and document Search endpoints are outside this Actor's contract because Naver discontinued them without a HUB replacement — choose the Shopping sibling for product catalogs instead.

### Practical scenario

An SEO lead enters `강남 맛집` with `searchType: "blog"` and their NAVER API HUB Client ID/Secret. The run returns ten blog rows with title, link, snippet, blogger name, and post date. They export CSV, then schedule the same input weekly for content monitoring.

### Quick start input

```json
{
  "query": "강남 맛집",
  "searchType": "blog",
  "maxResults": 10,
  "authStyle": "hub",
  "naverClientId": "YOUR_CLIENT_ID",
  "naverClientSecret": "YOUR_CLIENT_SECRET"
}
```

Create an application in the NAVER Cloud Platform console under NAVER API HUB, enable Search, and paste Client ID / Client Secret into the secret fields. Prefer `authStyle: "hub"` for new applications. Bring your own keys for every run.

### Input reference

| Field | Type | What it controls |
|---|---|---|
| `query` / `queries` | string / array | Keywords to search (up to 50 unique). |
| `searchType` | enum | `blog`, `news`, `web`, `cafe`, `image`, `kin`, `encyc`, `local`, `adult`, `errata`. |
| `maxResults` | integer | Run-wide row cap (default 30, max 1000). |
| `maxResultsPerQuery` | integer | Per-query pagination budget. |
| `sort` | enum | `sim`/`date` for most lists; `random`/`comment` for local. |
| `authStyle` | enum | `hub` (recommended) or `legacy`. |
| `naverClientId` / `naverClientSecret` | secret | Caller must supply their own BYOK credentials (`isSecret`; never written to dataset, output, or logs). |

### What data you receive

One dataset item is one Naver search result (or one adult/errata helper row).

```json
{
  "query": "강남 맛집",
  "searchType": "blog",
  "rank": 1,
  "title": "Best restaurants in Gangnam",
  "link": "https://blog.naver.com/example/123",
  "description": "A short snippet from Naver Search.",
  "bloggerName": "foodie",
  "postDate": "20260917",
  "source": "naver-api-hub",
  "collectedAt": "2026-09-17T12:00:00.000Z"
}
```

| Field | Meaning |
|---|---|
| `rank` | 1-based position within that query. |
| `title` / `description` | Cleaned text (HTML highlights stripped by default). |
| `source` | `naver-api-hub` or `naver-openapi-legacy`. |

`OUTPUT` and `RUN_SUMMARY` store `outcome`, `itemsPushed`, and `chargedEventCounts`. Download JSON, CSV, Excel, or HTML from the dataset.

### Pricing

This Actor uses **Pay per event** plus **platform usage** pass-through. Always check the live **Pricing** tab on the Actor page for the current event map — Treat the live Pricing tab as the current source of truth for event prices.

| Event | Price |
|---|---|
| `apify-actor-start` | $0.00005 / run |
| `search-result` | $0.005 / persisted row |

Upstream Naver Search is temporarily free within NAVER API HUB quotas when you bring your own keys. You pay Apify events plus platform compute on each run.

Typical cost: 10 blog rows ≈ `$0.05005` in events (plus small platform usage).

### Use through the API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~search-naver-open-api/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"강남 맛집","searchType":"blog","maxResults":5,"naverClientId":"...","naverClientSecret":"..."}'
```

### Agent / MCP prompt

> Use `khadinakbar/search-naver-open-api` (MCP tool `apify--search-naver-open-api`) when an AI agent needs official Naver Search JSON. Pass `query`, `searchType`, and caller-supplied `naverClientId`/`naverClientSecret`. Read `OUTPUT.outcome` and the default dataset for provenance (`source`, `collectedAt`). Bound cost with `maxResults` / pagination. Scope is HUB Search verticals only; for shopping or map places, call the sibling Actors named above.

### Best results

Provide Korean keywords, start with `maxResults: 10` to validate credentials, confirm Search is enabled on your HUB application, and schedule focused weekly monitors rather than unbounded dumps. Local search is capped at five public results per query by Naver — keep that specific bound in mind when you plan coverage.

### Builder's note

I built this as an HTTP-only Open API wrapper after sibling Naver Shopping and Map Actors needed Korean residential browsers for HTML. I found that NAVER API HUB Search stays cookieless and predictable for agents when callers bring their own Client ID/Secret, and my goal was a focused standalone Search workflow that pairs cleanly with those deeper scrapers.

### FAQ and responsible use

Use only credentials you are authorized to hold, and only for lawful collection of public search metadata under applicable laws and Naver API terms. Naver and NAVER API HUB are trademarks of Naver Corp. / NAVER Cloud. This independent Actor is not affiliated with, associated with, or endorsed by Naver. Report issues on the Actor Issues tab.

# Actor input Schema

## `query` (type: `string`):

Single Naver search keyword, usually Korean (e.g. '강남 맛집' or '아이폰 15'). Provide this, queries, or both. Merged and de-duplicated with queries\[]. Not a Naver Shopping product URL — for shopping use naver-product-shopping-scraper.

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

Batch of search keywords to run in one Actor run (up to 50 unique). Merged with query. Use for brand monitoring or multi-term SEO checks. Each item is a plain keyword string, not a URL.

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

Which Naver Search API vertical to call. blog/news/web/cafe/image/kin/encyc/local return ranked lists. adult and errata return one helper row per query. shop, book, and doc are discontinued and rejected.

## `maxResults` (type: `integer`):

Hard cap on dataset rows for the whole run across all queries. Default 30, maximum 1000. Local search is capped at 5 results per query by Naver.

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

Per-query pagination budget before moving to the next keyword. Defaults to maxResults. Naver allows display up to 100 and start up to 1000 (local: display max 5, start 1).

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

Optional sort. For most list verticals use sim (relevance) or date. For local use random or comment. Ignored for adult/errata/encyc.

## `authStyle` (type: `string`):

hub uses NAVER API HUB headers (X-NCP-APIGW-*). legacy uses older Developers Center headers (X-Naver-*) until 2027-06-30 fade-out. New applications should use hub.

## `stripHtmlTags` (type: `boolean`):

When true (default), remove Naver <b> highlight tags from title and description while keeping titleHtml/descriptionHtml originals.

## `naverClientId` (type: `string`):

Bring your own NAVER API HUB Client ID. The caller must supply their own secret for the run (or set NAVER\_CLIENT\_ID on the Actor). This secret is never written to the dataset, output, or logs. Placeholder example only: your-client-id.

## `naverClientSecret` (type: `string`):

Bring your own NAVER API HUB Client Secret. The caller must supply their own secret for the run (or set NAVER\_CLIENT\_SECRET on the Actor). This secret is never written to the dataset, output, or logs.

## Actor input object example

```json
{
  "query": "강남 맛집",
  "queries": [
    "강남 맛집",
    "서울 카페"
  ],
  "searchType": "blog",
  "maxResults": 10,
  "maxResultsPerQuery": 10,
  "sort": "sim",
  "authStyle": "hub",
  "stripHtmlTags": true,
  "naverClientId": "your-naver-client-id",
  "naverClientSecret": "your-naver-client-secret"
}
```

# Actor output Schema

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

Dataset items with query, searchType, rank, title, link, description, and type-specific fields.

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

Compact OUTPUT record with outcome, itemsPushed, charges, and warnings.

## `runSummary` (type: `string`):

Detailed RUN\_SUMMARY including query counts, providerRequests, and timing.

# 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 = {
    "query": "강남 맛집",
    "searchType": "blog",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/search-naver-open-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 = {
    "query": "강남 맛집",
    "searchType": "blog",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/search-naver-open-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 '{
  "query": "강남 맛집",
  "searchType": "blog",
  "maxResults": 10
}' |
apify call khadinakbar/search-naver-open-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/search-naver-open-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/smUXL1zxdUJNhUEOB/builds/5d4D2vH50iNfKCfNv/openapi.json