# Naver AI Overview Monitor — Briefing & Brand Match (`khadinakbar/naver-ai-overview-monitor`) Actor

Monitor Naver AI Briefing (AI Overview) for Korean search queries — AI answer text, cited sources, related questions, media, and optional brand/domain match. Camoufox + KR residential primary with optional SerpApi BYOK fallback. MCP-ready.

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

## Pricing

from $12.00 / 1,000 naver ai overview querieds

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 AI Overview Monitor — Korean AI Briefing & Brand Citations

**Naver AI Overview Monitor** helps Korean AEO / GEO teams and AI agents extract Naver's public **AI Briefing** (AI Overview / AI 브리핑) for search queries into structured JSON: answer text, cited sources, related questions, media, and optional brand or domain match.

Built for Apify: run via Console, API, schedules, or MCP (`apify--naver-ai-overview-monitor`). Billing is **Pay per event** plus Apify **platform usage**; the live Pricing tab is the current source of truth.

### Best fit for this Actor

- Use this Actor when you need the current Naver AI Briefing answer and citation list for Korean informational keywords.
- Prefer question-style Korean queries (for example `당뇨병 증상`) and Apify Residential proxies with country **KR**.
- Start with the Console prefill, confirm `briefingPresent` and `references[]`, then batch more keywords.
- For Google AI Overviews outside Korea, continue with [Google AI Overviews Scraper](https://apify.com/khadinakbar/google-ai-overviews-scraper) when you need Google AIO citations.
- For brand-name mentions across ChatGPT / Perplexity / Claude / Gemini, then use [AI Search Brand Monitor](https://apify.com/khadinakbar/ai-search-brand-monitor).
- Sibling routing: keep Naver Briefing work here; keep Google AIO and multi-LLM reputation work on the linked Actors above.

### Practical scenario

A Korean beauty brand tracks whether `선크림 추천` cites their domain. They paste the keyword, set `targetDomain` to their site, run weekly, and download the dataset. Each row shows whether an AI Briefing appeared, which domains Naver cited, and whether `brandMatch.matched` is true so the AEO team can prioritize content before the next campaign.

### Quick start input

```json
{
  "query": "당뇨병 증상",
  "targetDomain": "namu.wiki",
  "device": "desktop",
  "includeRelatedQuestions": true,
  "includeMedia": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "KR"
  }
}
```

Provide `query`, `queries`, or both (merged and de-duplicated, max 50).

### How to use

1. Open the Actor in Apify Console
2. Enter a Korean informational query such as `당뇨병 증상`
3. Optionally set `targetDomain` or `brandNames`
4. Keep Proxy on Apify Residential with country **KR**
5. Start the Actor and download JSON / CSV from the dataset

### What data you get

| Field | Description |
|-------|-------------|
| `query` | Search query checked |
| `briefingPresent` | Whether Naver showed an AI Briefing |
| `answerMarkdown` | Briefing answer text |
| `textBlocks[]` | Paragraph blocks |
| `references[]` | Cited sources (index, title, url, domain, snippet, source) |
| `referenceCount` / `uniqueDomainCount` | Citation counts |
| `media[]` / `relatedQuestions[]` | Optional media and follow-ups |
| `brandMatch` | Domain / brand-name match when configured |
| `source` | `camoufox` or `serpapi` |
| `scrapedAt` | ISO collection time |

#### Example output (one query)

```json
{
  "query": "당뇨병 증상",
  "device": "desktop",
  "serpUrl": "https://example.com/naver-search-serp?q=diabetes-symptoms",
  "briefingPresent": true,
  "answerMarkdown": "당뇨병의 주요 증상에는 다음이 포함됩니다…",
  "textBlocks": ["당뇨병의 주요 증상에는 다음이 포함됩니다…"],
  "references": [
    {
      "index": 1,
      "title": "당뇨병 - 관련 의학 정보",
      "url": "https://example-hospital.example/diabetes",
      "domain": "example-hospital.example",
      "snippet": null,
      "source": null
    }
  ],
  "referenceCount": 4,
  "uniqueDomainCount": 4,
  "media": [],
  "relatedQuestions": [{ "question": "당뇨병 진단 기준은?" }],
  "brandMatch": {
    "targetDomain": "namu.wiki",
    "matched": false,
    "position": null,
    "citedUrl": null,
    "matchCount": 0,
    "brandNameHits": []
  },
  "source": "camoufox",
  "scrapedAt": "2026-01-15T12:00:00.000Z",
  "warnings": []
}
```

`OUTPUT` and `RUN_SUMMARY` in the default key-value store hold `outcome`, `itemsPushed`, and charged event counts. Download the dataset as JSON, CSV, Excel, or HTML.

### Pricing

This Actor uses **Pay per event** plus Apify **platform usage**. The live Pricing tab is the current source of truth for billing details.

| Event | Price |
|-------|------:|
| Actor start | $0.00005 |
| `naver-ai-overview` (primary) | **$0.012** per resolved query |
| `brand-match-detected` | **$0.005** when a brand or domain match is recorded |

A ten-query monitoring sample with no brand hits is ten `naver-ai-overview` events plus start and Residential platform usage. Rows may show `briefingPresent: false` when Naver omits a Briefing; the query is still resolved when a dataset row is saved.

### Use through the API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~naver-ai-overview-monitor/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"당뇨병 증상","targetDomain":"namu.wiki","proxyConfiguration":{"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"],"apifyProxyCountry":"KR"}}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/naver-ai-overview-monitor').call({
  query: '당뇨병 증상',
  targetDomain: 'namu.wiki',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use with AI agents through Apify MCP

> Check Naver AI Briefing for 당뇨병 증상 with targetDomain namu.wiki. Return briefingPresent, references domains, and brandMatch. Read the dataset overview view and OUTPUT.outcome after the run. Budget: about $0.012 per query plus Residential KR platform usage. Scope: public Naver AI Briefing rows only. Provenance: source plus scrapedAt on each row.

Connect via <https://mcp.apify.com>. MCP tool: `apify--naver-ai-overview-monitor`. Keep concurrency low on the first call.

### Best results

- Prefer informational Korean queries for stable Briefing yield
- Use **Residential KR** proxies for the primary Camoufox path
- Keep concurrency at one worker while confirming yield
- Supply optional `serpApiKey` only when you want SerpApi BYOK fallback; the caller must supply their own key for the run, and the value is never written to the dataset, output, or logs
- Confirm `OUTPUT.outcome` and `itemsPushed` before treating an empty dataset as finished work

### Builder's note

I found that baking one Residential proxy URL into the Camoufox launch options reused a dead exit across every retry, so this Actor rotates sessions through Apify `proxyConfiguration` instead. I also found that Naver Open API Search products omit AI Briefing, which is why the public integrated-search page plus structural “AI 브리핑” parsing is the primary path, with optional SerpApi BYOK as a caller-supplied recovery route.

### Responsible use

Use only for lawful collection and analysis of public Naver Search AI Briefing content you are authorized to access. Follow applicable laws and Naver’s terms. Naver is a trademark of its respective owner. This independent Actor is not affiliated with, associated with, or endorsed by Naver Corp. SerpApi is a trademark of its respective owner. This Actor is not affiliated with or endorsed by SerpApi.

### Support

Open an issue on the Actor’s Issues tab for feedback or custom workflow help.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/naver-ai-overview-monitor/changelog.md

# Actor input Schema

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

One Korean or English query for Naver AI Briefing (e.g. '당뇨병 증상'). Provide this, queries, or both. Informational question-style queries trigger briefings most often. NOT a full search.naver.com URL.

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

Batch of queries for one run. Merged with query and de-duplicated. Max 50. One dataset row per query. NOT Google queries — these hit search.naver.com.

## `targetDomain` (type: `string`):

Bare domain(s) to match against briefing citations (e.g. 'amoremall.com' or comma-separated). When set, output includes brandMatch. Leave empty to skip domain matching. NOT a full URL.

## `brandNames` (type: `array`):

Case-insensitive brand name strings to scan in answer text and citation titles/snippets (e.g. \['설화수']). Complements targetDomain. Max 20.

## `device` (type: `string`):

Viewport to emulate. Defaults to desktop. Only desktop or mobile.

## `includeRelatedQuestions` (type: `boolean`):

Include Naver follow-up / related questions when present. Defaults to true.

## `includeMedia` (type: `boolean`):

Include media thumbnails attached to the briefing when present. Defaults to true.

## `serpApiKey` (type: `string`):

Optional SerpApi.com key for engine=naver\_ai\_overview when Camoufox is access-restricted. The caller must supply their own SerpApi key for the run; the value is never written to the dataset, output, or logs. Free tier at serpapi.com. Leave empty for Camoufox-only. NOT a Naver Open API key.

## `maxRetries` (type: `integer`):

Retries after Camoufox navigation failures. Defaults to 2.

## `forceSerpapi` (type: `boolean`):

Skip Camoufox and call SerpApi naver\_ai\_overview with your serpApiKey. Requires serpApiKey. Defaults to false.

## `proxyConfiguration` (type: `object`):

Defaults to Apify RESIDENTIAL with country KR. Datacenter proxies are usually blocked by Naver.

## Actor input object example

```json
{
  "query": "커피",
  "queries": [
    "선크림 추천",
    "쿠션 파운데이션 추천"
  ],
  "targetDomain": "namu.wiki",
  "brandNames": [
    "설화수"
  ],
  "device": "desktop",
  "includeRelatedQuestions": true,
  "includeMedia": true,
  "maxRetries": 2,
  "forceSerpapi": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "KR"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `usage` (type: `string`):

No description

## `runOutput` (type: `string`):

Machine-readable terminal outcome, useful result count, failure details, and PPE charge counts.

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

Detailed terminal status for automation, monitoring, and AI-agent workflows.

# 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": "당뇨병 증상",
    "queries": [
        "당뇨병 증상"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "KR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/naver-ai-overview-monitor").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": "당뇨병 증상",
    "queries": ["당뇨병 증상"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "KR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/naver-ai-overview-monitor").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": "당뇨병 증상",
  "queries": [
    "당뇨병 증상"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "KR"
  }
}' |
apify call khadinakbar/naver-ai-overview-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/naver-ai-overview-monitor"
        }
    }
}
```

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/rmVvKKKrV6MfCslOa/builds/g3Anz9ZaQlOPaL15s/openapi.json