# Naver Blog Brand Monitor — sponsored vs organic posts · $4/1k (`leoworks/naver-blog-brand-monitor`) Actor

Monitor a brand or product on Naver Blog (네이버 블로그), Korea's biggest review platform. This Naver Blog scraper collects posts by keyword and labels each one sponsored (체험단/협찬) or self-paid with evidence, plus sentiment and brand mentions — Korean social listening, no login.

- **URL**: https://apify.com/leoworks/naver-blog-brand-monitor.md
- **Developed by:** [Leoworks](https://apify.com/leoworks) (community)
- **Categories:** Social media, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.40 / 1,000 blog posts

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Blog Brand Monitor — sponsored vs organic posts

**For brand marketers, PR teams and agencies in Korea** who need to know what Naver Blog — the #1 place Koreans read product, restaurant and beauty reviews — says about a brand, and **how much of it is paid (체험단 / 협찬) versus organic word of mouth**, for $4 per 1,000 posts plus $1 per 1,000 judgments.

Enter a brand or product keyword and get every matching post with:

- **Sponsored vs self-paid** — 체험단 / 협찬 / 원고료 (sponsored) vs 내돈내산 (self-paid) vs unclear, **with the evidence** (disclosure sentence or review-platform banner)
- **Affiliate flag** — Coupang Partners, Naver Shopping Connect and similar commission links
- **Sentiment** — positive / neutral / negative toward the product or place
- **Brand mentions** — did the post mention each brand you care about (Korean or English spelling)?
- Post metadata — title, blog, publish time, snippet, image count, likes and comments, and full text on request

**Use it to:** monitor a brand on Naver Blog (네이버 블로그) · sponsored post detection for Korean influencer marketing · count 체험단 (experience-group) posts vs organic reviews · Korean social listening · Naver blog scraper with sentiment.

### Output sample

Real rows from runs `4MpsWAuVQeJEw1AxJ` (query "다이슨 에어랩 후기", brands 다이슨 / Dyson) and `68ansfQ5krx8lYz3J` (query "라운드랩 선크림", brands 라운드랩 / Round Lab), both 2026-10-06. English in parentheses is added here for readers; the Actor returns the Korean title.

| title (Korean) | sponsored.label (probability, method) | evidence | sentiment | brandMentions | likeCount / commentCount |
|---|---|---|---|---|---|
| 다이슨 에어랩 아이디 내돈내산 후기｜8년 쓴 컴플리트와 비교… (Dyson Airwrap i.d. self-paid review, compared with my 8-year-old Complete) | self_paid (0.95, rule) | `self_paid_phrase`: "…내돈내산 후기…" | neutral | 다이슨 true · Dyson true | 0 / 0 |
| 차홍 에어스타일러 (Chahong air styler) | self_paid (0.95, rule) | `self_paid_phrase`: "…#내돈내산 다이슨에어랩을 사고…" | neutral | 다이슨 true · Dyson true | 0 / 0 |
| 다이슨 에어랩 코안다 2x 후기 (Dyson Airwrap Coanda 2x review) | unclear (1.00, model) | — | neutral | 다이슨 true · Dyson true | 4 / 0 |
| 바르는 코엔자임q10 추천, 하이퍼셀·이데베논 앰플… (Topical coenzyme Q10 ampoules) | sponsored (0.95, model) | — | positive | 다이슨 false · Dyson false | 1 / 0 |
| \[내돈내산] 벌써 2통째! 라운드랩 자작나무 수분선크림 푸른자차 실사용 후기 (Self-paid: my 2nd tube of Round Lab birch sunscreen) | self_paid (0.95, rule) | `self_paid_phrase`: "\[내돈내산]…" | positive | 라운드랩 true · Round Lab true | 3 / 0 |

Every row also has `url`, `blogName`, `publishedAt`, `snippet`, `imageCount`, `reactions` (공감 breakdown), `sponsored.affiliate` and the probabilities behind each label — see **Output** below.

### Input example

The form default — one keyword, the 8 most recent posts, one brand (about $0.04, 9 seconds):

```json
{
  "queries": ["라운드랩 선크림"],
  "brandNames": ["라운드랩"],
  "maxPostsPerQuery": 8
}
```

For monitoring, raise `maxPostsPerQuery` (up to 1,000), add `"dateFrom": "2026-09-01"` and both spellings of your brand (`["라운드랩", "Round Lab"]`). Posts are deduplicated across queries. Sort by most recent (default) for monitoring, or by relevance.

### Pricing

Pay only for results — no subscription.

| Event | Price | When |
|---|---|---|
| `post` | $0.004 | One blog post collected (metadata, snippet, image count; full text if requested). |
| `post-judged` | $0.001 | Sponsored/self-paid, sentiment and brand-mention judgments for one post (only when judging is on). |

That is **$4 per 1,000 posts collected** plus **$1 per 1,000 posts judged** (sponsorship, sentiment and brand mentions) — $5 per 1,000 posts with everything on. **First run with the form defaults: about $0.04** (8 posts, 9 seconds).

**Cost examples**

| Run | Collection only | With judgments |
|---|---|---|
| 100 posts | $0.40 | $0.50 |
| 1,000 posts | $4.00 | $5.00 |
| 5,000 posts | $20.00 | $25.00 |

With the free $5 monthly Apify credit you can collect and judge about **1,000 posts**.

Posts that fail to load are reported with an `error` field and **not charged**. If you set a maximum cost per run the Actor stops cleanly; if the budget only covers collection, judging is turned off and collection continues.

### Works with

- **Apify API, JavaScript and Python clients** — start a run and read the dataset like any Actor (`leoworks/naver-blog-brand-monitor`).
- **Apify Schedules** — a daily run with `dateFrom` keeps a rolling log of new posts; our own monitoring runs this Actor every morning.
- **Claude, Cursor and Claude Code through the Apify MCP server** — see the next section (verified 2026-10-06).
- **Korean Review Classifier** — the same complaint, sentiment and motive labels for any review dataset: [leoworks/korean-review-classifier](https://apify.com/leoworks/korean-review-classifier).

### Use with Claude, Cursor or Claude Code (MCP)

Add the Apify MCP server with this Actor as a tool and ask your agent in plain language — for example *"Find the latest 30 Naver Blog posts about 라운드랩 선크림 and tell me how many are sponsored (체험단) and what the self-paid ones say."* The agent calls the tool `leoworks--naver-blog-brand-monitor` and reads the posts with `get-dataset-items`.

Claude Desktop or Cursor (`mcp.json`):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=leoworks/naver-blog-brand-monitor",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

Claude Code: `claude mcp add --transport http apify "https://mcp.apify.com?tools=leoworks/naver-blog-brand-monitor" --header "Authorization: Bearer YOUR_APIFY_TOKEN"`. Leave out the header to sign in with OAuth in the browser instead. Your Apify token is in Console → Settings → API & Integrations. We verified this setup with the Apify MCP server (v0.17.2) on 2026-10-06.

### Output (one row per post)

```json
{
  "query": "라운드랩 선크림",
  "url": "https://m.blog.naver.com/…/224428209119",
  "title": "눈시림없고 백탁없는 라운드랩 자작나무 수분 선크림",
  "blogName": "솝비의 나날들",
  "publishedAt": "2026-10-01T04:53:26.388Z",
  "snippet": "안녕하세요 솝비입니다! 요즘 외출할 때 선크림은…",
  "likeCount": 132,
  "reactions": { "like": 128, "impressive": 4 },
  "commentCount": 81,
  "imageCount": 6,
  "sponsored": { "label": "sponsored", "probability": 0.99, "method": "rule", "evidence": [{ "type": "platform_banner", "source": "revu.net" }], "affiliate": false },
  "sentiment": { "label": "positive", "probability": 0.97, "confidence": 0.95 },
  "brandMentions": [{ "brand": "라운드랩", "mentioned": true, "probability": 1, "method": "exact" }]
}
```

`likeCount` is the number shown under the post (all reactions — 공감, 감사, 칭찬 …; breakdown in `reactions`) and `commentCount` the number of comments, both read without login. If the counts cannot be loaded they are `null`; the post is still returned.

#### How sponsorship is decided

1. **Rules first** — Korean FTC-style disclosure sentences (원고료, 제품을 제공받아, 협찬, 체험단을 통해…) and banners/links of review-experience platforms (Revu, ReviewNote, Dinner Queen and others) → `sponsored`; explicit 내돈내산 / 직접 구매 → `self_paid`. Evidence is returned.
2. **Model second** — posts without explicit evidence are judged by Jev, TypeSafe's decision model, and stay `unclear` unless it is confident.
3. Affiliate commission disclosures ("…수수료를 제공받습니다") are reported as `affiliate: true`, not as sponsorship.

**Accuracy:** 92% on 50 hand-labelled posts (beauty, restaurants, camping, hair tools). Hidden sponsorship that is never disclosed cannot be detected by anyone — `unclear` is an honest answer.

#### Summary by keyword and brand (REPORT)

Each run also saves a **REPORT** record (Output tab → *Summary by keyword and brand*) at no extra charge — for all posts, for each keyword and for each brand you listed: the sponsored / self-paid / unclear split, affiliate-link share, sentiment of all posts and of **self-paid posts only** (the closest thing to organic customer voice), posts per month, and the 3 latest negative posts that are not sponsored.

```json
{
  "brand": "라운드랩",
  "posts": 42,
  "judged": 42,
  "sponsorship": { "sponsored": 0.548, "self_paid": 0.333, "unclear": 0.119 },
  "affiliateShare": 0.071,
  "sentiment": { "positive": 0.857, "neutral": 0.095, "negative": 0.048 },
  "selfPaidSentiment": { "positive": 0.714, "neutral": 0.143, "negative": 0.143 },
  "postsByMonth": { "2026-09": 25, "2026-10": 17 },
  "latestNegativePosts": [{ "title": "…", "url": "https://blog.naver.com/…", "publishedAt": "2026-10-02T…", "sponsorship": "self_paid" }]
}
```

### Limits

| Item | Limit |
|---|---|
| Posts per query | Up to 1,000 (what Naver search returns) |
| Brands to check | Up to 10 per run |
| Speed | About 998 posts with judgments in 6 minutes |
| Source | Naver Blog (blog.naver.com) posts written with Naver's SmartEditor |
| Personal data | Blog name and nickname only — no real names, emails or phone numbers |

### Optional: use your own NAVER API Hub key

By default posts are discovered through Naver web search. For very large daily volumes you can plug in **your own** NAVER Cloud key: create a NAVER Cloud account → *NAVER API Hub* → create an application with **Search** → copy the key ID and key into the two Advanced fields (stored as secrets). The search API is free up to Naver's daily limit at the time of writing.

### FAQ

**Which AI makes the judgments?** Jev, TypeSafe's decision model (version `jev-1.13.0`, pinned). Jev answers each label with a calibrated probability instead of generated text, so the same input gets the same answer from run to run. We re-measure accuracy on our labelled test set before we change the model version. Only the post title and text (first 2,500 and last 1,500 characters) and your brand names are sent to Jev; blog names and nicknames are not.

**Is this the official Naver API?** Post discovery uses Naver's public mobile search by default (or your own NAVER API Hub key); post content is read from public mobile blog pages. No Naver login is used.

**Does it generate summaries?** No — it collects posts and adds labels with probabilities.

### Disclaimer

> Independent tool — not affiliated with, endorsed by or sponsored by NAVER Corp. "Naver" is a trademark of its owner and is used only to describe the data source.

### Reviews and support

If this Actor saved you time, a short review on Apify Store helps others find it. Questions or a query that does not work? Open an issue in the **Issues** tab — we answer within a day.

### Changelog

See the Changelog tab.

# Changelog

This Actor's version history is a separate document: https://apify.com/leoworks/naver-blog-brand-monitor/changelog.md

# Actor input Schema

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

Naver Blog search queries — usually your brand or product name in Korean (e.g. 라운드랩 선크림, 다이슨 에어랩 후기).

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

Brands whose mention you want checked in every post (Korean or English, e.g. 라운드랩, Round Lab). Up to 10.

## `maxPostsPerQuery` (type: `integer`):

Up to 1,000 posts per query. The form starts at 8 for a quick, low-cost first run (default when omitted via API: 50).

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

Most recent posts first (good for monitoring) or Naver relevance order.

## `dateFrom` (type: `string`):

Only posts published on or after this date (YYYY-MM-DD).

## `judge` (type: `object`):

Which judgments to add (charged as post-judged per post when any is on): sponsored (체험단/협찬 vs 내돈내산), sentiment, brandMention.

## `includeFullText` (type: `boolean`):

Add the full post text to each row (larger output).

## `ncpApiKeyId` (type: `string`):

Optional. Use your own NAVER Cloud (NCP) NAVER API Hub key for post discovery instead of web search — steadier for large daily volumes. See README.

## `ncpApiKey` (type: `string`):

Optional secret key paired with the key ID above.

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

Posts processed in parallel.

## `residentialFallback` (type: `boolean`):

Retry failing requests through Korean residential proxy.

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

Default Apify datacenter proxy works for most users.

## `healthCheck` (type: `boolean`):

Internal: fail the run when results look degraded (used by the developer's scheduled checks).

## Actor input object example

```json
{
  "queries": [
    "라운드랩 선크림"
  ],
  "brandNames": [
    "라운드랩"
  ],
  "maxPostsPerQuery": 8,
  "sort": "recent",
  "judge": {
    "sponsored": true,
    "sentiment": true,
    "brandMention": true
  },
  "includeFullText": false,
  "maxConcurrency": 10,
  "residentialFallback": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "healthCheck": false
}
```

# Actor output Schema

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

No description

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

No description

## `report` (type: `string`):

No description

# 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": [
        "라운드랩 선크림"
    ],
    "brandNames": [
        "라운드랩"
    ],
    "maxPostsPerQuery": 8,
    "judge": {
        "sponsored": true,
        "sentiment": true,
        "brandMention": true
    },
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("leoworks/naver-blog-brand-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 = {
    "queries": ["라운드랩 선크림"],
    "brandNames": ["라운드랩"],
    "maxPostsPerQuery": 8,
    "judge": {
        "sponsored": True,
        "sentiment": True,
        "brandMention": True,
    },
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("leoworks/naver-blog-brand-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 '{
  "queries": [
    "라운드랩 선크림"
  ],
  "brandNames": [
    "라운드랩"
  ],
  "maxPostsPerQuery": 8,
  "judge": {
    "sponsored": true,
    "sentiment": true,
    "brandMention": true
  },
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call leoworks/naver-blog-brand-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,leoworks/naver-blog-brand-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/JFRsMRO22clFLJZDJ/builds/UXxHOlGcKhveDZdux/openapi.json