# Naver News & Blog Scraper - Cafe Keyword Monitor (Official API) (`koreadata-lab/naver-news-blog-search-api`) Actor

Keyword monitoring for Korea: Naver News, Blog, Cafe and web documents via the official Naver Search API (NAVER API HUB), run with your own key. Only-new alerts, date filter, English publisher names, dedup. No author data.

- **URL**: https://apify.com/koreadata-lab/naver-news-blog-search-api.md
- **Developed by:** [Koreadata Lab](https://apify.com/koreadata-lab) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 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 News & Blog Scraper - Cafe Keyword Monitor (Official API)

A Naver News scraper and Naver Blog scraper for **keyword monitoring in Korea**: it collects **Korean news (네이버 뉴스)**, **Naver Blog** posts, **Naver Cafe** posts and Korean web documents for your keywords through the **official Naver Search API on NAVER API HUB** (Naver Cloud Platform), so there is no page scraping and no blocking. You run it with **your own API key**; it is automation software for your own searches, not a data feed. It is built for alerts and media monitoring: "only new since last run" mode, a date cutoff, publisher names in English, and de-duplication across keywords.

> **Live-tested on Apify: YES (2026-10-29).** Keyword "삼성전자" on news, blog, cafe and web documents: 400 items in 7 s through NAVER API HUB keys. Publisher domain is always filled; an English publisher name is filled only for outlets that have an established English name (about 1 in 7 in that run).

### Why this actor

- **Official API:** no blocking and no proxies, and it costs far less than headless scraping.
- **NAVER API HUB ready:** uses the new Naver Cloud Platform endpoints first and still accepts old NAVER Developers keys as a fallback until they stop working on 2027-06-30.
- **Alert mode (`onlyNewItems`):** remembers the links it already returned (ids only, kept less than 21 days), so a scheduled run only outputs new items, and you only pay for new items.
- **English publisher names** for about 50 major Korean outlets (Yonhap, Chosun, JoongAng, Hankyung, Maeil Business, KBS and others), plus the publisher domain.
- **Privacy by design:** blogger nicknames and profile links are **dropped**. Cafe posts keep only the community name.

### Input

```json
{
  "keywords": ["삼성전자", "\"K-뷰티\" -광고"],
  "sources": ["news", "blog", "cafearticle"],
  "sort": "date", "maxItemsPerSource": 100, "publishedAfter": "2026-10-01", "onlyNewItems": true,
  "apiProvider": "auto",
  "apiHubClientId": "YOUR_API_HUB_CLIENT_ID", "apiHubClientSecret": "YOUR_API_HUB_CLIENT_SECRET"
}
```

Sources: `news`, `blog`, `cafearticle`, `webkr` (web documents). Sort: `date` or `sim` (relevance). Optional fallback: `legacyClientId` / `legacyClientSecret` (an existing developers.naver.com app). `apiProvider`: `auto` (API HUB, then legacy on 401/403), `apihub` or `legacy`.

### Output

Example (illustrative values), one news item:

```json
{
  "keyword": "삼성전자", "source": "news", "rank": 1,
  "title": "삼성전자, 3분기 영업이익 \"시장 기대 상회\"", "snippet": "삼성전자가 28일 잠정 실적을 발표했다...",
  "url": "https://n.news.naver.com/mnews/article/001/0015000000",
  "originalUrl": "https://www.yna.co.kr/view/AKR20261028000100003",
  "publisherDomain": "yna.co.kr", "publisherNameEn": "Yonhap News Agency",
  "cafeName": null, "publishedAt": "2026-10-28T00:12:00.000Z", "fetchedAt": "2026-10-29T06:00:00.000Z"
}
```

Blog items have `publisherDomain: "blog.naver.com"` and a day-only `publishedAt` (`"2026-10-27"`). Cafe items have `cafeName` and no date.

### Endpoints used (official)

Primary, **NAVER API HUB** (Naver Cloud Platform):
`GET https://naverapihub.apigw.ntruss.com/search/v1/{news|blog|cafearticle|webkr}` with headers `X-NCP-APIGW-API-KEY-ID` and `X-NCP-APIGW-API-KEY`.

Fallback until 2027-06-30, **legacy NAVER Developers** keys:
`GET https://openapi.naver.com/v1/search/{news|blog|cafearticle|webkr}.json` with headers `X-Naver-Client-Id` and `X-Naver-Client-Secret`.

Getting API HUB keys: Naver Cloud Platform console > Services > Application Services > **NAVER API HUB** > Application > register an application and add the Search APIs (news, blog, cafe, web documents) > copy the Client ID and Secret from **인증 정보**. API HUB currently lists a free tier for the Search API (25,000 calls per day); Naver says the free policy may change. A Naver Cloud Platform account (with a payment method) is required.

### API keys (secret inputs)

- All four credential fields are **secret inputs** (`isSecret` in the input schema): Apify stores them encrypted and hides them in the Console and in API responses.
- The actor sends them only as request headers to the two official Naver hosts above. They are **never logged, never written** to the dataset or key-value stores, and never put in URLs.
- If a key is exposed, reissue it in the provider console (API HUB: 인증 정보 > 재발급) and update the input.

### Terms notice (read before use)

This actor is a tool **you run with your own NAVER key**. You are the API user under the NAVER API terms (developers.naver.com, 이용약관) and the NAVER API HUB / Naver Cloud Platform terms, and you are responsible for how you use the results. Among other things, Naver's search API special terms (as revised 2026-10-07) say:

- results may be stored on a server only for history lookup and for **at most 21 days**; no other copying, storing or caching;
- no providing or **selling the results to third parties**;
- no feeding the results **into AI** for training, improvement, evaluation or display;
- no earning revenue from the search API service itself.

What the actor does to stay inside these rules: the `onlyNewItems` memory keeps only item ids and the date first seen, and drops them before 21 days; it keeps no titles or snippets between runs. Run datasets live in **your** Apify account: delete them (or rely on your plan's data retention) within 21 days, and do not copy them into long-lived storage. The developer of this actor does not see, keep or resell your results.

### Limitations

- The Naver API returns **at most 1,000 items per keyword per source**, and only a title and snippet, not the full article text. Fetching full article text is out of scope on purpose (copyright).
- Blog dates are day-only, and cafe posts have no date in the API, so `publishedAfter` is not applied to them. Web documents have no date at all.
- Snippets are Naver's, in Korean. No machine translation is included (sending them to an AI translator would conflict with the terms above).
- If the API HUB free tier ends, calls will be billed to your Naver Cloud account by Naver, not by this actor.
- Because `onlyNewItems` forgets ids after less than 21 days, a very old item that Naver re-surfaces can appear again.

### Pricing

- **Free from 12 November 2026.** Until then the Store shows the earlier pay-per-result price, which is being removed.
- You pay only Apify's normal platform usage for the run (a fraction of a cent for a typical run).
- Naver data is fetched with your own key; Naver does not charge for it on the current free tier.
- Why free: Naver's API terms do not allow earning revenue from the API itself, so this actor is offered at no charge.

### FAQ

**Do I need my own API key?**
Yes. Register an application in the NAVER API HUB (Naver Cloud Platform console), add the Search APIs, and paste the Client ID and Secret into the input. The steps are under "Endpoints used" above. Existing NAVER Developers keys also work until 2027-06-30.

**How fresh is the data?**
Each run queries the Naver Search API live, so you get whatever Naver's search index holds at that moment. Nothing is cached between runs except the item ids used by `onlyNewItems`.

**Can I schedule it daily?**
Yes. Create an Apify Schedule (daily or hourly) with `onlyNewItems: true` and `sort: "date"`. Each run then returns only items it has not returned in the last 21 days, so you pay only for new items.

**What does a typical run cost?**
It is free (from 12 November 2026); you only pay Apify platform usage, usually well under one cent per run.

**Is this legal, and where does the data come from?**
The data comes from Naver's official Search API, called with your key under Naver's API terms. No pages are scraped. Read the terms notice above: it limits storage to 21 days and forbids reselling the results or feeding them into AI.

# Actor input Schema

## `keywords` (type: `array`):

Search keywords (Korean works best). Supports Naver operators like "exact phrase" and -exclude. Max 30 per run.

## `sources` (type: `array`):

Which Naver search verticals to query. One API call returns up to 100 items.

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

Use 'Newest first' for monitoring. (webkr ignores sort.)

## `maxItemsPerSource` (type: `integer`):

Naver API limit is 1,000 (start ≤ 1000).

## `publishedAfter` (type: `string`):

Optional YYYY-MM-DD. With 'Newest first', paging stops once items get older than this date. Not applied to webkr (no date).

## `onlyNewItems` (type: `boolean`):

Remember item links in a named key-value store and skip ones already output. Ideal for scheduled alerts (you pay only for new items).

## `historyStoreName` (type: `string`):

Named key-value store for 'only new items' memory.

## `apiProvider` (type: `string`):

NAVER API HUB (Naver Cloud Platform) is the primary path. Legacy NAVER Developers keys keep working only until 2027-06-30 and no new ones are issued.

## `apiHubClientId` (type: `string`):

Naver Cloud Platform console > Services > NAVER API HUB > Application > 인증 정보. Add Search API (뉴스·블로그·카페·웹문서) to the application. Sent only as the X-NCP-APIGW-API-KEY-ID header.

## `apiHubClientSecret` (type: `string`):

Client Secret of the same API HUB application. Sent only as the X-NCP-APIGW-API-KEY header.

## `legacyClientId` (type: `string`):

Optional. An existing developers.naver.com app key. Used only if API HUB keys are missing or rejected, and only until 2027-06-30.

## `legacyClientSecret` (type: `string`):

Optional. Client Secret of the same legacy app.

## Actor input object example

```json
{
  "keywords": [
    "삼성전자",
    "K-뷰티"
  ],
  "sources": [
    "news",
    "blog"
  ],
  "sort": "date",
  "maxItemsPerSource": 100,
  "publishedAfter": "",
  "onlyNewItems": false,
  "historyStoreName": "naver-search-monitor-history",
  "apiProvider": "auto"
}
```

# Actor output Schema

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

All result rows in the default dataset.

# 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 = {
    "keywords": [
        "삼성전자",
        "K-뷰티"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("koreadata-lab/naver-news-blog-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 = { "keywords": [
        "삼성전자",
        "K-뷰티",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("koreadata-lab/naver-news-blog-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 '{
  "keywords": [
    "삼성전자",
    "K-뷰티"
  ]
}' |
apify call koreadata-lab/naver-news-blog-search-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,koreadata-lab/naver-news-blog-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/c5XpOhA6an0YpwrYa/builds/cQ0a3giN1XepauGGv/openapi.json