# Naver Blog Comments Scraper (네이버 블로그 댓글) (`hgservices/naver-blog-comments-scraper`) Actor

Scrape all comments and replies from Naver Blog (네이버 블로그) posts: comment text, commenter name and blog, date, likes, stickers and images, with each reply linked to its parent comment. Paste post URLs and export every comment thread.

- **URL**: https://apify.com/hgservices/naver-blog-comments-scraper.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 $1.00 / 1,000 scraped comments

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 Comments Scraper (네이버 블로그 댓글)

**Scrape all the comments and replies of [Naver Blog](https://section.blog.naver.com) posts.** Paste post URLs and get **one row per comment** with the **text, commenter name, commenter blog, date, likes, sticker and images**. Each reply is **linked to its parent comment**, so you can rebuild every comment thread.

네이버 블로그 글의 댓글과 답글을 수집합니다. 로그인 없이 댓글 내용, 작성자, 작성자 블로그, 작성일, 공감 수, 스티커, 이미지를 JSON, CSV, Excel로 내려받으세요.

Export the comments 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 Comments Scraper do?

Give the scraper one or more Naver Blog post URLs. For each post, it returns all the public comments (댓글) and replies (답글), newest first:

- **Comment data** — the text (with line breaks), sticker, attached images, likes (공감), and the dates when the comment was written and edited.
- **Commenter data** — the commenter's name, their own Naver blog ID and URL, and their profile image.
- **Thread data** — `isReply`, `parentCommentId` and `replyCount`, so you can rebuild each conversation.
- **Blog owner replies** — `isBlogOwner: true` marks the comments and replies of the post's author.
- **Post status report** — a summary that tells you, for each post, if it had comments, had comments turned off, or was not found.
- **Many posts in one run** — add as many post URLs as you need. A post that you enter two times is scraped one time.

### Use cases

- **Customer and audience research** — Read what readers say about a product, restaurant or brand under the most-read blog reviews.
- **Influencer campaign tracking** — Measure the comments that sponsored and influencer posts get, and how the blogger answers.
- **Sentiment analysis** — Collect clean Korean comment text for sentiment analysis, NLP, topic modeling or AI pipelines.
- **Blogger and community discovery** — Every commenter has a Naver blog, so you find the active bloggers in a niche.
- **Engagement monitoring** — Run the scraper on a schedule and collect the new comments on your own posts or your competitors' posts.

### Input

| Field                | Type     | Default | Description                                                                                        |
| -------------------- | -------- | ------- | -------------------------------------------------------------------------------------------------- |
| `postUrls`           | string\[] | —       | Naver Blog post URLs. Required                                                                     |
| `maxCommentsPerPost` | integer  | `1000`  | The most comments (replies included) to return for each post, newest first. `0` = all the comments |

These post 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}`
- `https://blog.naver.com/{blogId}?Redirect=Log&logNo={logNo}`
- `{blogId}/{logNo}`, for example `blogpeople/224425969565`

#### Input examples

**The newest 1,000 comments of one post**

```json
{
    "postUrls": ["https://blog.naver.com/blogpeople/224425969565"]
}
```

**All the comments of two posts**

```json
{
    "postUrls": ["https://blog.naver.com/blogpeople/224425969565", "https://m.blog.naver.com/paperchan/224438187954"],
    "maxCommentsPerPost": 0
}
```

**Only the newest 20 comments of each post** — good for a daily schedule

```json
{
    "postUrls": ["https://blog.naver.com/blogpeople/224425969565", "https://blog.naver.com/paperchan/224438187954"],
    "maxCommentsPerPost": 20
}
```

### Output

You get one row for each comment or reply. Here is a comment and the blog owner's reply to it:

```json
[
    {
        "postUrl": "https://blog.naver.com/paperchan/224438187954",
        "blogId": "paperchan",
        "logNo": "224438187954",
        "postTitle": "(청주) 극동반점",
        "commentId": "907345894548963539",
        "parentCommentId": null,
        "isReply": false,
        "replyCount": 1,
        "authorName": "부부식객관",
        "authorBlogId": "bubuohlak",
        "authorBlogUrl": "https://blog.naver.com/bubuohlak",
        "authorProfileImageUrl": "https://blogimgs.pstatic.net/imgs/emot/emo11.gif",
        "isBlogOwner": false,
        "text": "청주 극동반점의 옛날식 짜장면과 기본에 충실한 잡채라니 궁금하네요! 잡채 재료와 식감까지 자세히 써주셔서 잘 읽었어요 😊",
        "stickerUrl": null,
        "imageUrls": [],
        "likeCount": 0,
        "createdAt": "2026-10-11T11:01:55.000Z",
        "updatedAt": "2026-10-11T11:01:55.000Z",
        "scrapedAt": "2026-10-11T15:36:43.491Z"
    },
    {
        "postUrl": "https://blog.naver.com/paperchan/224438187954",
        "blogId": "paperchan",
        "logNo": "224438187954",
        "postTitle": "(청주) 극동반점",
        "commentId": "907346444237668468",
        "parentCommentId": "907345894548963539",
        "isReply": true,
        "replyCount": 0,
        "authorName": "레이니",
        "authorBlogId": "paperchan",
        "authorBlogUrl": "https://blog.naver.com/paperchan",
        "authorProfileImageUrl": "https://blogimgs.pstatic.net/item/personacon/11/38/1443811.gif",
        "isBlogOwner": true,
        "text": "^^",
        "stickerUrl": null,
        "imageUrls": [],
        "likeCount": 0,
        "createdAt": "2026-10-11T11:10:27.000Z",
        "updatedAt": "2026-10-11T11:10:27.000Z",
        "scrapedAt": "2026-10-11T15:36:43.485Z"
    }
]
```

#### Output fields

| Field                           | Description                                                                                 |
| ------------------------------- | ------------------------------------------------------------------------------------------- |
| `postUrl`, `blogId`, `logNo`    | The post that the comment belongs to                                                        |
| `postTitle`                     | The post title                                                                              |
| `commentId`                     | Naver's ID of the comment                                                                   |
| `parentCommentId`               | For a reply: the `commentId` of the comment that it answers. `null` for a top-level comment |
| `isReply`                       | `true` for a reply (답글), `false` for a top-level comment                                  |
| `replyCount`                    | The number of replies to a top-level comment. `0` for a reply                               |
| `authorName`                    | The commenter's display name                                                                |
| `authorBlogId`, `authorBlogUrl` | The commenter's own Naver blog                                                              |
| `authorProfileImageUrl`         | The commenter's profile image                                                               |
| `isBlogOwner`                   | `true` when the post's author wrote the comment or reply                                    |
| `text`                          | The comment text, with line breaks. `null` for a comment with only a sticker or image       |
| `stickerUrl`                    | The image URL of the comment's sticker, or `null`                                           |
| `imageUrls`                     | The images attached to the comment                                                          |
| `likeCount`                     | Likes (공감) on the comment                                                                 |
| `createdAt`, `updatedAt`        | When the comment was written and last edited (ISO 8601, UTC)                                |
| `scrapedAt`                     | When the comment was scraped (ISO 8601, UTC)                                                |

#### Status of each post

The key-value store record **POSTS** (in the **Output** tab: **Status of each post**) lists every input post with its status, the number of comments returned, and the comment count that Naver shows on the post:

```json
[
    {
        "input": "https://blog.naver.com/blogpeople/224425969565",
        "postUrl": "https://blog.naver.com/blogpeople/224425969565",
        "status": "ok",
        "comments": 594,
        "naverCommentCount": 602
    },
    {
        "input": "https://blog.naver.com/PostView.naver?blogId=qmfosej&logNo=224430277591",
        "postUrl": "https://blog.naver.com/qmfosej/224430277591",
        "status": "comments_disabled",
        "comments": 0,
        "naverCommentCount": 31
    }
]
```

| Status              | Meaning                                                                           |
| ------------------- | --------------------------------------------------------------------------------- |
| `ok`                | Comments were returned                                                            |
| `no_comments`       | The post has no public comments                                                   |
| `comments_disabled` | The author turned comments off. Naver then shows no comments, not even older ones |
| `not_found`         | The post or blog does not exist, is private, or was deleted                       |
| `invalid_url`       | The input is not a Naver Blog post URL                                            |
| `budget_reached`    | The run stopped at the maximum cost per run that you set, before this post ended  |
| `failed`            | Naver did not answer after many retries. Run the post again                       |

### How to use Naver Blog Comments Scraper

You can run the scraper in four ways: in Apify Console, with the Apify API, with the Apify API clients for JavaScript and Python, or from an AI assistant such as Claude or ChatGPT.

#### In Apify Console (no coding)

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, for example `https://blog.naver.com/blogpeople/224425969565`.
3. In **Max comments per post**, set the number of comments that you want for each post. The default is 1,000. Use `0` to get all the comments.
4. Click **Start**.
5. Open the **Output** tab. View the comments as a table, or download them as JSON, CSV, Excel, XML or HTML.

To run the scraper again with the same input, save the input as a **task**. Add a **schedule** to the task to run it every hour, day or week.

#### With the Apify API (HTTP)

Get your API token in Apify Console under **Settings → API & Integrations**. Replace `<YOUR_API_TOKEN>` in the examples below.

**Run the scraper and get the comments in one call** — good for small runs that end in less than 5 minutes:

```bash
curl -X POST "https://api.apify.com/v2/acts/hgservices~naver-blog-comments-scraper/run-sync-get-dataset-items?format=json" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "postUrls": ["https://blog.naver.com/blogpeople/224425969565"], "maxCommentsPerPost": 200 }'
```

Change `format=json` to `format=csv` or `format=xlsx` to get a spreadsheet.

**Start a large run, then read the results when it ends:**

```bash
## 1. Start the run. The answer contains the run ID in data.id.
curl -X POST "https://api.apify.com/v2/acts/hgservices~naver-blog-comments-scraper/runs" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{ "postUrls": ["https://blog.naver.com/blogpeople/224425969565", "https://blog.naver.com/paperchan/224438187954"], "maxCommentsPerPost": 0 }'

## 2. Check the run. Wait until data.status is SUCCEEDED.
curl "https://api.apify.com/v2/actor-runs/<RUN_ID>" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>"

## 3. Download the comments.
curl "https://api.apify.com/v2/actor-runs/<RUN_ID>/dataset/items?format=json" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>"

## 4. Read the status of each post.
curl "https://api.apify.com/v2/actor-runs/<RUN_ID>/key-value-store/records/POSTS" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>"
```

#### With the JavaScript / Node.js client

Install the client with `npm install apify-client`. This example gets the comments, rebuilds the threads, and reads the status of each post:

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

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

const run = await client.actor('hgservices/naver-blog-comments-scraper').call({
    postUrls: ['https://blog.naver.com/blogpeople/224425969565'],
    maxCommentsPerPost: 0,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const comment of items.filter((c) => !c.isReply)) {
    console.log(`${comment.authorName}: ${comment.text}`);
    for (const reply of items.filter((r) => r.parentCommentId === comment.commentId)) {
        console.log(`    ↳ ${reply.authorName}${reply.isBlogOwner ? ' (blog owner)' : ''}: ${reply.text}`);
    }
}

const status = await client.keyValueStore(run.defaultKeyValueStoreId).getRecord('POSTS');
console.log(status.value);
```

#### With the Python client

Install the client with `pip install apify-client` (version 3.0 or later). This example finds the most active commenters on two posts:

```python
from collections import Counter

from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("hgservices/naver-blog-comments-scraper").call(run_input={
    "postUrls": [
        "https://blog.naver.com/blogpeople/224425969565",
        "https://blog.naver.com/paperchan/224438187954",
    ],
    "maxCommentsPerPost": 0,
})
if run is None:
    raise RuntimeError("The run was not found.")

comments = list(client.dataset(run.default_dataset_id).iterate_items())
commenters = Counter(c["authorBlogUrl"] for c in comments if not c["isBlogOwner"])
for blog_url, count in commenters.most_common(10):
    print(count, blog_url)

status = client.key_value_store(run.default_key_value_store_id).get_record("POSTS")
print(status["value"] if status else None)
```

#### With Claude, ChatGPT and other AI assistants (MCP)

The scraper works as a tool for AI assistants through the [Apify MCP server](https://mcp.apify.com/). Your assistant finds the scraper, reads its input options, runs it, and uses the comments in its answer. You sign in to Apify the first time that you connect.

To give the assistant only this scraper, use this server URL:

```text
https://mcp.apify.com?tools=hgservices/naver-blog-comments-scraper
```

To let the assistant also search and run other Actors, use `https://mcp.apify.com`.

**Claude (claude.ai and Claude Desktop)** — Go to **Settings → Connectors**. Add a custom connector with the server URL above.

**Claude Code** — Run this command:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=hgservices/naver-blog-comments-scraper"
```

**ChatGPT** — Turn on **Developer mode** in **Settings → Apps & Connectors → Advanced settings**. Then go to **Settings → Apps & Connectors → Create**, and enter the server URL above as the **MCP Server URL**.

**Cursor, VS Code and other MCP clients** — Add the server to your MCP configuration:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=hgservices/naver-blog-comments-scraper"
        }
    }
}
```

Then ask in plain language:

> Use the Naver Blog Comments Scraper to get all the comments of https://blog.naver.com/blogpeople/224425969565 and summarize them in English.

> Get the comments of these 5 review posts and tell me which complaints come up most often.

> Is the reader sentiment positive or negative under this post? Give examples.

### Integrations and scheduling

Connect the scraper 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 ends.

Use **Schedules** in Apify Console to run the scraper automatically, for example every day to collect the new comments on your campaign posts.

### Good to know

- **Rebuild threads.** A top-level comment has `parentCommentId: null`. Its replies have its `commentId` in `parentCommentId`.
- **Track new comments.** Comments come newest first. Schedule the scraper with a small **Max comments per post** to get only the latest comments.
- **Replies count toward the limit.** **Max comments per post** counts top-level comments and replies together.
- **Secret and deleted comments** are not in the dataset. Naver does not show their text or author to visitors.

### Related Actors

- **[Naver Blog Post Scraper](https://apify.com/hgservices/naver-blog-post-scraper)** — the full content of Naver Blog posts by URL.
- **[Naver Blog Profile Scraper](https://apify.com/hgservices/naver-blog-profile-scraper)** — a blogger's profile, follower and visitor counts, and full post list. Use it to get the post URLs of a blog, then send them to this scraper.

### FAQ

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

**Why do I get fewer comments than Naver's comment count?**
Naver's count includes secret comments (비밀 댓글) and deleted comments. Visitors cannot see their text or author, so the scraper skips them. Compare `comments` and `naverCommentCount` in the **POSTS** record.

**Are replies included?**
Yes. Replies (답글) are in the same dataset, with `isReply: true` and the `parentCommentId` of the comment that they answer.

**Why does a post with old comments show `comments_disabled`?**
When the author turns comments off, Naver hides all the comments of the post, also the old ones.

**Can I scrape comments from a private post?**
No. The scraper reads only posts that every visitor can open. A private post gets the status `not_found`.

**Is it legal to scrape Naver Blog comments?**
The scraper collects only publicly available content and never signs in. Comments contain personal data, such as names and blog IDs. Use the data in line with Naver's Terms of Service and the laws that apply to you, including personal-data rules such as Korea's PIPA and the GDPR.

### 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 scraper is not affiliated with or endorsed by Naver.

# Actor input Schema

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

Naver Blog post URLs, one per line — e.g. https://blog.naver.com/{blogId}/{logNo}. The mobile form (m.blog.naver.com) and PostView.naver?blogId=\&logNo= links also work.

## `maxCommentsPerPost` (type: `integer`):

The most comments (replies included) to return for each post, newest first. Set to 0 for all comments. You are billed per comment, so use this to control cost.

## Actor input object example

```json
{
  "postUrls": [
    "https://blog.naver.com/blogpeople/224425969565"
  ],
  "maxCommentsPerPost": 1000
}
```

# Actor output Schema

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

No description

## `posts` (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 = {
    "postUrls": [
        "https://blog.naver.com/blogpeople/224425969565"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/naver-blog-comments-scraper").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 = { "postUrls": ["https://blog.naver.com/blogpeople/224425969565"] }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/naver-blog-comments-scraper").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 '{
  "postUrls": [
    "https://blog.naver.com/blogpeople/224425969565"
  ]
}' |
apify call hgservices/naver-blog-comments-scraper --silent --output-dataset

```

## MCP server setup

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

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/1y8IeHcwk44uHQDsK/builds/Zvmf9GLVT4heianLH/openapi.json
