# Naver Search Scraper & API - Web, Blog and Cafe Results (`s-r/naver-search`) Actor

Get Naver search results as clean rows: position, title, URL, snippet and domain from the web tab, plus author, blog ID and date for blog posts and cafe articles. For Korean SEO, brand monitoring and influencer research. Empty searches are free.

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

## Pricing

$2.00 / 1,000 search results

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 Scraper & Naver Search API: Web, Blog and Cafe Results

Naver Search Scraper works as a Naver search API for Korean SEO, brand monitoring and
blog research: send keywords, get organic web, blog and cafe results from Naver
as clean dataset rows. Use it to research Korean keywords, monitor brand mentions,
identify relevant bloggers or compare which pages appear for your campaign queries.
Each result is a separate row with its search query, position, title, destination URL
and snippet. Blog results also include the author, blog identifier and publication
date when Naver shows them.

No Naver developer account, client ID or browser is needed. You choose the queries,
the tab, the sort order and how many results you want per query; the actor handles
pagination and returns a flat table you can export to JSON, CSV or Excel.

### What Naver Search Scraper returns

Choose the web tab for general website visibility, the blog tab for posts and creator
discovery, or the cafe tab for community articles. These are separate Naver search
surfaces. Positions describe the selected tab and sort order, so compare runs that
use the same settings. A position in blog search is not a position in web search.

The actor excludes blog advertisements and removes duplicate destination URLs within
each query. It keeps the first occurrence and numbers the remaining results from one.
A page that appears for two different queries remains a result for both queries.
This allows you to group rows by keyword without losing the relationships between
keywords and destinations.

This version returns information shown in the search results. It does not open every
post to collect its full text, comments, likes or other engagement statistics. A
snippet is an excerpt supplied by Naver and may differ from the current page content.

### How to use the Naver search API in four steps

1. Open the actor and enter one or more keywords in **Search queries**, in Korean or English.
2. Pick the **tab**: `web` for websites, `blog` for Naver Blog posts, `cafe` for Naver Cafe articles.
3. Pick the **sort** order (`relevance` or `date`) and set **maxResults** per query.
4. Start the run and download the dataset, or read it from the Apify API in your own code.

You can also start the actor from the Apify API, a schedule, a webhook or an
integration such as Make, Zapier or n8n, so the same Naver search runs every day or
week without manual work.

### Input and search settings

Provide a `queries` array of search phrases. Korean phrases and English terms both work.
Leading and trailing whitespace is removed, empty entries are skipped, and identical
queries are processed once. You can supply up to 50 unique queries, each containing
up to 500 characters. A list with no usable queries returns an input error.

The `tab` setting accepts `web`, `blog` or `cafe`, with `web` as the default. The
`sort` setting accepts `relevance` or `date`. Relevance preserves Naver's relevance
order; date requests newest results first. Date sorting is useful for recent brand
mentions, while relevance is useful for keyword visibility and content research.

`maxResults` limits the number of unique results for each query. Its default is 30
and its supported range is 1 to 1000. Web results are selected from the website
collections in Naver’s combined search pages; blog posts, answers and advertisements
in those pages are excluded. The available web total varies by query and sort order.
The actor follows the available pages until the requested limit or the source ends.
A requested maximum is a limit, not a guarantee that Naver has that many results.

| field | type | default | what it does |
|---|---|---|---|
| `queries` | array of strings | (required) | Keywords to search, up to 50 unique queries |
| `tab` | `web`, `blog`, `cafe` | `web` | Which Naver search tab to collect |
| `sort` | `relevance`, `date` | `relevance` | Naver's order or newest first |
| `maxResults` | integer 1–1000 | 30 | Unique results per query |

For the query used in the captured examples:

```json
{
  "queries": ["캠핑 의자"],
  "tab": "blog",
  "sort": "relevance",
  "maxResults": 30
}
```

Apify handles continuation automatically. You do not need to provide a cursor for a
normal actor run. The number of rows ultimately returned depends on your input,
available search results and the applicable free-user limit.

### Output fields and exports

Results are written to the default dataset. Download them as JSON, CSV or Excel from
the dataset view, or read them using the Apify dataset API. The run's `OUTPUT` record
reports delivery counts and status, and an `errors` record describes queries that
could not be collected when applicable.

Every row includes `source`, `fetched_at`, `query`, `position`, `url`, `title`,
`snippet`, `domain`, `engine`, `country`, `tab` and `sort`. The source is
`naver-search`; engine distinguishes `naver_web`, `naver_blog` and `naver_cafe`.
The country is `kr`, representing the Korean search market. `fetched_at` is a UTC
timestamp recording when that result page was retrieved.

Web rows may include a displayed breadcrumb URL, `site_name` and `ai_summary`.
Naver sometimes presents an AI summary as a table instead of a text excerpt; such
rows can have an empty snippet. Blog rows expose `author`, `author_url`, `blog_id`,
`post_id`, `image_count` and `thumbnail_url` when those values appear in search.
`blog_id` and `post_id` identify posts on Naver's blog hosts; both are null for
external blogs, which retain their URL, author and other available search fields.
Cafe rows expose `cafe_name`, `cafe_id` and `post_id`. The cafe search tab does not
show a reliable article author, so its author field is null. Missing optional
information is returned as null rather than guessed.

Web URLs point to the real destination page. When Naver wraps a shop or brand link
in its own click-tracking address, the actor returns the destination behind it, and
`domain` is that destination's domain. Duplicates are removed on the destination URL,
so one brand site does not appear twice under different tracking links.

#### Output example: a Naver blog search result

This is position 5 of the blog search for 캠핑 의자 (camping chair), exactly as the
actor returned it on 5 October 2026:

```json
{
  "source": "naver-search",
  "fetched_at": "2026-10-05T00:37:23.000Z",
  "query": "캠핑 의자",
  "position": 5,
  "url": "https://blog.naver.com/petit360/224428388470",
  "title": "캠핑 의자 고를 때 무게만 보고 계신가요? 두 번 사기 전에 꼭 앉아보고 체크할 것 3가지",
  "snippet": "[ 불멍 4시간도 편안한 하이백 릴렉스체어 보러가기] 캠핑의자 1+1 휴대용 경량 릴렉스체어 LAKSELV naver.me 확인 ③. 내 테이블·화로대 높이와 맞나요? 의외로 많이 놓치는 부분입니다. 의자만 편해도 테이블과 높이가 안 맞으면 식사할 때마다 허리를 숙이거나 어깨를 들어 올려야 해요. 의자 유형 좌면 높이(대략) 어울리는 테이블 추천 상황 로우체어 25~30cm 로우...",
  "domain": "blog.naver.com",
  "engine": "naver_blog",
  "country": "kr",
  "tab": "blog",
  "sort": "relevance",
  "site_name": null,
  "ai_summary": false,
  "author": "동키의 하루",
  "author_url": "https://blog.naver.com/petit360",
  "blog_id": "petit360",
  "post_id": "224428388470",
  "cafe_name": null,
  "cafe_id": null,
  "date_text": "4일 전",
  "published_date": "2026-10-01",
  "image_count": null,
  "thumbnail_url": "https://search.pstatic.net/common/?src=http%3A%2F%2Fblogfiles.naver.net%2FMjAyNjEwMDFfMTkx%2FMDAxNzkwODM5MzQ0NzQ3.nvgMQZHGRuSy_xxHZ5GXWtT6J7bzink75_OUaTMp0ogg.9KuzIpAWo-S3rLihplf7_EqvKCS60xNNYpbpJc4A4Jcg.PNG%2Fimage.png%231024x1024&type=ff192_192"
}
```

#### Output example: a Naver web search result

Position 3 of the web search for the same query, from the same day:

```json
{
  "source": "naver-search",
  "fetched_at": "2026-10-05T00:37:43.000Z",
  "query": "캠핑 의자",
  "position": 3,
  "url": "https://konucamping.com/",
  "title": "코누 공식 온라인몰",
  "snippet": "[코누캠핑] 윈드스크린,블랙코팅타프,캠핑의자 1 1,경량 캠핑테이블,릴렉스체어, 롤테이블",
  "domain": "konucamping.com",
  "engine": "naver_web",
  "country": "kr",
  "tab": "web",
  "sort": "relevance",
  "site_name": "코누",
  "ai_summary": false,
  "author": null,
  "author_url": null,
  "blog_id": null,
  "post_id": null,
  "cafe_name": null,
  "cafe_id": null,
  "date_text": null,
  "published_date": null,
  "image_count": null,
  "thumbnail_url": null,
  "displayed_url": "konucamping.com"
}
```

### Publication dates

`date_text` preserves the date displayed by Naver. `published_date` is a calendar day
in Korea, formatted as YYYY-MM-DD. It is derived from an absolute date or a relative
value expressed in minutes, hours or days. A value expressed in weeks or a broad
time interval does not identify an exact day, so `published_date` remains null.
Use `date_text` when your analysis needs to preserve that uncertainty.

### Use cases for Naver search data

- **Korean SEO and rank tracking.** Naver is a leading search engine in Korea.
  Run your target keywords on the web tab every week and track the position of your
  domain and your competitors' domains over time.
- **Brand monitoring.** Search your brand and product names on the blog and cafe tabs
  with `sort: date` to see new posts and community discussions as they appear.
- **Influencer and blogger discovery.** Blog rows carry `blog_id`, `author` and
  `author_url`, so you can group results by blogger and find the creators who write
  most about your category.
- **Content research.** Titles and snippets of the top blog posts show which angles,
  questions and formats rank for a keyword in Korea.
- **Agency reporting.** Export the dataset to a spreadsheet or BI tool and report Naver
  visibility next to Google visibility for clients entering the Korean market.

### Naver Search Scraper compared with other options

**Naver's official search API** (Naver Developers) returns blog, cafe, news and other
results as JSON, but it needs an application registration, client credentials and a
daily call quota, and its results are not guaranteed to match what a user sees on the
search page. This actor returns the results as they appear on Naver's search tabs, with positions,
without any Naver account.

**General SERP API providers** cover Naver as one engine among many, usually with a
monthly plan. This actor is pay per result with no subscription, and it returns blog
author, blog ID and cafe fields as their own columns.

**Other Apify actors** for Naver often focus on one surface, such as blog posts only,
or charge per page or per query on top of results. Here one actor covers web, blog and
cafe with the same output schema, and searches without results cost nothing.

### Pricing and free-user limit

The result event counts delivered dataset rows. There is no custom run-start charge,
and searches that return no rows incur no result charge. The current price per
result is shown in the actor's Pricing tab. A higher `maxResults` can increase the
number of delivered rows, but it does not create a charge for unavailable results.

Runs by users without a paid Apify plan return at most ten rows in total. This limit
applies across all queries in the run. Paid users can request the supported result
volume without that ten-row cap. The run output indicates when the free-user cap
applied, so account for it when comparing counts from different runs.

### FAQ

#### Why did I receive fewer rows than maxResults?

Naver may have fewer matching results, web search has a source limit, and duplicate
URLs are removed. The free-user cap can also reduce delivery. Check the run output
and warnings before treating the number of rows as the size of the full search index.

#### Are result positions comparable across runs?

Positions reflect Naver's order at collection time, after removing advertisements
and duplicates. Compare the same query, tab and sort setting. Search results change
over time, so retain `fetched_at` alongside position when building a history.

#### Can I get full blog posts or comments?

This actor collects the search-result fields. Full post bodies, reactions and comments
are outside its current output. Destination URLs and blog identifiers can help you
connect these results to a separate content collection workflow.

#### What happens when a query has no results or collection fails?

A query with no results returns no dataset rows. When other queries succeed, their
rows are retained. Collection problems are recorded in the run output or errors;
inspect warnings when a run reports partial results. No replacement rows are invented.

#### Are web result URLs Naver tracking links?

No. Some Naver web results link through a Naver payment or click-tracking address.
The actor returns the shop or brand page behind that link, so `url` and `domain`
show who actually ranks. A wrapped link without a usable destination is left out
instead of being delivered as a Naver address.

#### Do I need a Naver API key or client ID?

No. You only need an Apify account. The actor does not use Naver Developers
credentials, so there is no Naver quota to manage.

#### Can I search in English or only in Korean?

Both work. Queries are sent to Naver's Korean search market as you type them. Most
Naver results are in Korean, so Korean keywords usually return more and more relevant
results than their English translations.

#### Can I call this Naver search API from my own code?

Yes. Start the actor with the Apify API or one of the Apify client libraries for
JavaScript and Python, wait for the run to finish and read the dataset items. The
rows have the same fields as the examples above.

# Actor input Schema

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

Up to 50 unique Naver search queries. Whitespace and empty entries are removed; each query may contain up to 500 characters.

## `tab` (type: `string`):

Search organic web pages, blog posts, or cafe articles.

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

Naver relevance order or newest first. Positions follow the selected order.

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

Maximum unique results for each query, up to 1000. Web results are filtered from Naver's combined search pages; the available total varies by query and sort order.

## Actor input object example

```json
{
  "queries": [
    "캠핑 의자"
  ],
  "tab": "web",
  "sort": "relevance",
  "maxResults": 30
}
```

# Actor output Schema

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

One row per unique search result per query.

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

Counts, status and free-tier information.

## `errors` (type: `string`):

Queries that could not be collected.

# 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("s-r/naver-search").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("s-r/naver-search").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 s-r/naver-search --silent --output-dataset

```

## MCP server setup

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

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/UjMqKm74EmoaLMBdJ/builds/uE9IWiTtMy3X7XBr2/openapi.json