# Naver Blog Sponsored Post Detector (협찬 / 내돈내산) (`hgservices/naver-blog-sponsored-post-detector`) Actor

Detect sponsored Naver Blog (네이버 블로그) posts: label each post as sponsored (협찬, 체험단, 원고료), affiliate (쿠팡 파트너스) or self-paid (내돈내산), with the evidence — campaign platform banners, disclosure sentences, affiliate links and Naver's receipt badge. Check post URLs or keywords.

- **URL**: https://apify.com/hgservices/naver-blog-sponsored-post-detector.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 analyzed 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 Sponsored Post Detector (협찬 / 내돈내산)

**Find out which [Naver Blog](https://section.blog.naver.com) posts are sponsored.** The detector reads each post and labels it **sponsored** (협찬, 체험단, 원고료), **affiliate** (쿠팡 파트너스), **verified own purchase** (Naver's 내돈내산 receipt badge), **claimed own purchase** (내돈내산 in the text) or **no disclosure found**. It also gives the **evidence** for each label. Check a list of post URLs, or the top Naver Blog posts for a keyword.

Export the results as JSON, CSV, Excel, XML or HTML, or read them from the API.

No Naver account. No login. No coding needed.

### What does Naver Blog Sponsored Post Detector do?

Korean bloggers must disclose sponsorship, but they do it in many ways: a banner image from a review-campaign platform, a sentence at the end of the post, a hashtag or an affiliate notice. The detector checks every post for these signals:

- **Campaign platform banners** — banner images and links of 체험단 platforms such as REVU (레뷰), 리뷰노트, 디너의여왕, 슈퍼멤버스, 서울오빠, 강남맛집, 미블, 포포몬 and 블로그몰.
- **Disclosure sentences** — for example `상품 및 서비스만을 제공받고 솔직하게 작성된 후기입니다`, `소정의 원고료를 받아 작성하였습니다` or `#협찬`.
- **Not a disclosure** — sentences that only mention the words are not counted. Examples: offers (`협찬 문의 환영합니다`), denials (`지원받지 않고 작성했어요`), questions (`체험단 활동 시 주의할 점이 있나요?`) and freebies that every guest gets (`서비스로 제공받은 계란찜`).
- **Affiliate links and notices** — 쿠팡 파트너스 links (`link.coupang.com`, `coupa.ng`), Olive Young affiliate links, and the commission notice.
- **Naver receipt badge** — the `내돈내산 인증` badge that Naver shows when the author verified a visit with a receipt.
- **내돈내산 mentions** — the author's own statement that they paid.

Each post gets one label. The strongest signal sets the label:

| Label                   | Meaning                                                             |
| ----------------------- | ------------------------------------------------------------------- |
| `sponsored`             | A campaign platform banner or a sponsorship disclosure sentence     |
| `affiliate`             | An affiliate link or a commission notice (쿠팡 파트너스 and others) |
| `own_purchase_verified` | Naver's 내돈내산 receipt badge, and no sponsorship signal           |
| `own_purchase_claimed`  | The author writes 내돈내산, and there is no other signal            |
| `no_disclosure_found`   | No signal                                                           |

### Use cases

- **Brand and market research** — Measure how much of the Naver Blog conversation about your product or category is paid.
- **Honest consumer research** — Keep only self-paid reviews (내돈내산), or remove sponsored posts from your data.
- **체험단 campaign compliance** — Check that every post of your review campaign has a disclosure.
- **Competitor intelligence** — See which campaign platforms your competitors use, and how many sponsored posts they have.
- **Influencer vetting** — Check the share of sponsored posts on a blogger's posts before you work with them.
- **Clean training data** — Label Korean review posts as paid or self-paid for analysis and AI models.

### How to detect sponsored Naver Blog posts in Apify Console

1. Click **Try for free** and sign in to Apify. A free account is enough.
2. In **Post URLs**, add one Naver Blog post URL per line.
3. Or, in **Check posts by keyword**, add one keyword per line, for example `홍대 카페`.
4. For keywords, set **Max posts per keyword**. The default is 50.
5. Click **Start**.
6. Open the **Output** tab. View the labels as a table, or download them as JSON, CSV, Excel, XML or HTML.

### Input

| Field                | Type     | Default | Description                                                                                                                |
| -------------------- | -------- | ------- | -------------------------------------------------------------------------------------------------------------------------- |
| `postUrls`           | string\[] | —       | Naver Blog post URLs to check                                                                                              |
| `keywords`           | string\[] | —       | Search keywords. The detector checks the posts that Naver Blog search returns for each keyword, in Naver's relevance order |
| `maxPostsPerKeyword` | integer  | `50`    | The most posts to check for each keyword, up to 1,000. `0` = all of them                                                   |

Give at least one post URL or one keyword. These URL forms all work:

- `https://blog.naver.com/{blogId}/{logNo}`
- `https://m.blog.naver.com/{blogId}/{logNo}`
- `https://blog.naver.com/PostView.naver?blogId={blogId}&logNo={logNo}`

#### Input examples

**The top 50 posts for one keyword**

```json
{
    "keywords": ["홍대 카페"]
}
```

**Two keywords and one post URL**

```json
{
    "keywords": ["홍대 카페", "선크림 추천"],
    "maxPostsPerKeyword": 100,
    "postUrls": ["https://blog.naver.com/mingu_u99/224424664977"]
}
```

### Output

You get one row for each post. Example:

```json
{
    "keyword": "홍대 카페",
    "rank": 5,
    "url": "https://blog.naver.com/mingu_u99/224424664977",
    "blogId": "mingu_u99",
    "logNo": "224424664977",
    "title": "홍대 대형 카페 내면의 발견 커피와 말차라떼 마시며 쉬어가기 좋은 곳",
    "nickName": "새벽샛별",
    "publishedAt": "2026-09-28T03:35:29.706Z",
    "label": "sponsored",
    "isSponsored": true,
    "receiptVerified": false,
    "naverOwnPurchaseFlag": false,
    "campaignPlatforms": ["슈퍼멤버스"],
    "campaignLinks": [
        "https://d3i7y4ugnppb9p.cloudfront.net/contract/track/8efc4340-b7fa-11f1-8b2b-1bfcfb09171d/banner-small.png"
    ],
    "disclosureSentences": [],
    "affiliateLinks": [],
    "affiliateSentences": [],
    "ownPurchaseMentions": [],
    "contentLength": 3085,
    "status": "ok",
    "scrapedAt": "2026-10-11T16:30:46.713Z"
}
```

#### Output fields

| Field                                  | Description                                                                                       |
| -------------------------------------- | ------------------------------------------------------------------------------------------------- |
| `keyword`, `rank`                      | For keyword input: the keyword and the post's position in Naver Blog search. `null` for URL input |
| `url`, `blogId`, `logNo`               | The post                                                                                          |
| `title`, `nickName`, `publishedAt`     | The post title, the author and the publish time (ISO 8601, UTC)                                   |
| `label`, `isSponsored`                 | The label (see the table above), and `true` when the label is `sponsored`                         |
| `receiptVerified`                      | `true` when the post has Naver's 내돈내산 receipt badge                                           |
| `naverOwnPurchaseFlag`                 | For keyword input: Naver's own 내돈내산 flag in the search results                                |
| `campaignPlatforms`, `campaignLinks`   | The campaign platforms found, and the banner or link URLs                                         |
| `disclosureSentences`                  | The sponsorship sentences found in the post                                                       |
| `affiliateLinks`, `affiliateSentences` | The affiliate links and commission notices                                                        |
| `ownPurchaseMentions`                  | The sentences where the author writes 내돈내산                                                    |
| `contentLength`                        | The length of the post text, in characters                                                        |
| `status`                               | `ok`, `empty` (no post body), `not_found` (deleted or private) or `fetch_failed`                  |
| `scrapedAt`                            | When the post was checked (UTC)                                                                   |

### Use Naver Blog Sponsored Post Detector with the Apify API

Run the detector and read the results from any programming language with the [Apify API](https://docs.apify.com/api/v2). Get your API token in Apify Console under **Settings → API & Integrations**, and replace `<YOUR_API_TOKEN>` below.

**HTTP (cURL)** — run the detector and get the labels in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/hgservices~naver-blog-sponsored-post-detector/run-sync-get-dataset-items?format=json" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "keywords": ["홍대 카페"], "maxPostsPerKeyword": 30 }'
```

Change `format=json` to `format=csv` or `format=xlsx` to get a spreadsheet. For many keywords or posts, start the run with `POST /v2/acts/hgservices~naver-blog-sponsored-post-detector/runs` and read the dataset when the run finishes.

**JavaScript / Node.js** — count the labels for each keyword:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const run = await client.actor('hgservices/naver-blog-sponsored-post-detector').call({
    keywords: ['홍대 카페', '선크림 추천'],
    maxPostsPerKeyword: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const counts = {};
for (const post of items.filter((p) => p.status === 'ok')) {
    counts[post.keyword] ??= {};
    counts[post.keyword][post.label] = (counts[post.keyword][post.label] ?? 0) + 1;
}
console.table(counts);
```

**Python** (`apify-client` 3.0 or later) — check your campaign posts and list the posts with no disclosure:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("hgservices/naver-blog-sponsored-post-detector").call(run_input={
    "postUrls": [
        "https://blog.naver.com/mingu_u99/224424664977",
        "https://blog.naver.com/otherblog/224424425341",
    ],
})
if run is None:
    raise RuntimeError("The run was not found.")

for post in client.dataset(run.default_dataset_id).iterate_items():
    if post["status"] == "ok" and post["label"] != "sponsored":
        print("No sponsorship disclosure:", post["url"], post["label"])
```

### Use sponsored post data in Claude, ChatGPT and other AI assistants

This detector works as a tool for AI assistants through the [Apify MCP server](https://mcp.apify.com/). Your assistant can find the detector, read its input options, run it, and use the labels and the evidence in its answer.

**Claude (claude.ai or Claude Desktop)** — Go to **Settings → Connectors**, add a custom connector, and enter `https://mcp.apify.com`. Sign in to Apify when Claude asks.

**Claude Code**

```bash
claude mcp add --transport http apify https://mcp.apify.com
```

**ChatGPT** — Turn on **Developer mode** in **Settings → Apps & Connectors → Advanced settings**. Then create a connector with the MCP server URL `https://mcp.apify.com`.

**Cursor, VS Code and other MCP clients** — Add `https://mcp.apify.com` as a remote MCP server. To give the assistant only this detector, use `https://mcp.apify.com?tools=hgservices/naver-blog-sponsored-post-detector`.

Then ask in plain language:

> Use the Naver Blog Sponsored Post Detector to check the top 100 posts for 선크림 추천. What share is sponsored, and which campaign platforms appear most?

> Check these 20 campaign posts and tell me which ones have no sponsorship disclosure.

> Find the self-paid (내돈내산) reviews among the top 50 posts for 홍대 카페 and summarize them in English.

### Integrations and scheduling

Connect the detector to the tools that you already use with [Apify integrations](https://apify.com/integrations): **Google Sheets, Slack, Zapier, Make, n8n, Airbyte, Keboola** and more. Use **webhooks** to call your own endpoint when a run finishes.

Use **Schedules** in Apify Console to run the detector automatically, for example every week on your campaign posts to confirm that the disclosures stay in place.

### Pricing

This detector uses **pay-per-event** pricing. You pay only for the posts that it checks:

- **Search page** — one charge for each page of up to 30 Naver Blog search results that the detector reads for a keyword. A page that adds no labeled posts to your dataset is free. Post URLs that you give directly have no search pages.
- **Post analyzed** — one charge for each post that was read and labeled.

The prices of the events are on the **Pricing** tab. Deleted, private or unreadable posts are in the dataset with their status, and they are free. Use **Max posts per keyword** to control the cost of a run. Apify's free plan lets you try the detector at no cost.

### Good to know

- **Read the evidence, not only the label.** Each row keeps the platform, link or sentence behind its label, so you can check it or apply your own rules.
- **Compare keywords.** Run several keywords in a category and compare the share of `sponsored` posts.
- **Text and links only.** The detector reads the post text and the addresses of links and images. It does not read text that is inside photos.

### Related Actors

- **[Naver Blog Search Scraper](https://apify.com/hgservices/naver-blog-search-scraper)** — Naver Blog posts by keyword, with optional full content.
- **[Naver Blog Post Scraper](https://apify.com/hgservices/naver-blog-post-scraper)** — the full content of posts by URL.
- **[Naver Blog Rank Tracker](https://apify.com/hgservices/naver-blog-rank-tracker)** — the Naver search rank of your blog posts for your keywords.
- **[Naver Blog Comments Scraper](https://apify.com/hgservices/naver-blog-comments-scraper)** — all the comments and replies of Naver Blog posts.

### FAQ

**Do I need a Naver account?**
No. You need only an Apify account. The detector reads the public posts that every visitor can see without an account.

**How many posts get a label?**
It depends on the keyword. In our tests on popular keywords, about 4 of 10 posts had a signal. The other posts had no disclosure.

**Does `no_disclosure_found` mean "not sponsored"?**
No. It means that the post shows no disclosure. Some posts are promotional, but they disclose nothing.

**Does it read text inside images?**
No. In our tests, we checked the images of posts with no signal and found no disclosure images. Image text recognition would add almost nothing.

**I found a campaign platform that the detector does not know. What do I do?**
Open an issue on the **Issues** tab with an example post URL. We add new platforms on request.

**Is it legal to analyze Naver Blog posts?**
The detector reads only publicly available content and never signs in. Use the data in line with Naver's Terms of Service and the laws that apply to you. A label is an automatic result from the post content. It is not a legal finding about the author.

### Support

Did you find a bug, or do you need a field that is not here? Open an issue on the **Issues** tab. Custom solutions are available on request.

This detector is not affiliated with or endorsed by Naver.

# Actor input Schema

## `postUrls` (type: `array`):

Naver Blog post URLs to check, one per line — e.g. https://blog.naver.com/{blogId}/{logNo}. The m.blog.naver.com form and PostView.naver links also work.

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

Search keywords, one per line — e.g. 홍대 카페, 선크림 추천. The Actor checks the posts that Naver Blog search returns for each keyword, in Naver's relevance order.

## `maxPostsPerKeyword` (type: `integer`):

The most posts to check for each keyword, up to 1,000. 0 = all of them. You are billed per checked post, so use this to control cost.

## Actor input object example

```json
{
  "keywords": [
    "홍대 카페"
  ],
  "maxPostsPerKeyword": 50
}
```

# Actor output Schema

## `dataset` (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 = {
    "keywords": [
        "홍대 카페"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/naver-blog-sponsored-post-detector").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": ["홍대 카페"] }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/naver-blog-sponsored-post-detector").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": [
    "홍대 카페"
  ]
}' |
apify call hgservices/naver-blog-sponsored-post-detector --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hgservices/naver-blog-sponsored-post-detector"
        }
    }
}
```

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/mB8zzI4VWpU2Qj9OM/builds/fruXdLeOHrgM5Ak46/openapi.json
