# Naver Blog Scraper | 네이버 블로그 Full Text by Blogger or Keyword (`themineworks/naver-blog-posts-scraper`) Actor

Scrape Naver Blog (네이버 블로그) posts with full text: every post of the bloggers you name, no key needed, or keyword search through Naver's official Search API with your own free key. Exact publish time, category, comments, body text, images and links. Monitor mode.

- **URL**: https://apify.com/themineworks/naver-blog-posts-scraper.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Social media, Marketing, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.29 / 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 Scraper | 네이버 블로그 Full Text by Blogger or Keyword

[![20 Naver blog posts with full text in 11 seconds, from two public bloggers](https://api.apify.com/v2/key-value-stores/cUXz95yxflDho41nn/records/naver-blog-posts-scraper-hero.png)](https://console.apify.com/actors/H5fauUzxE2wiQVGf2/input)

From **The Mine Works**, makers of [Threads Scraper](https://apify.com/themineworks/threads-scraper) and [B2B Leads Finder](https://apify.com/themineworks/b2b-leads-finder), with more than 140,000 runs across our actors.

### Why choose this actor?

- **Full text, not a preview.** Every post comes with its whole body text, its publish time to the second, its category, its images and its links. Our proof run read **20 posts from 2 bloggers in 11 seconds**, every one with full text (about 2,500 characters on average), and all 23 requests were answered. A post whose page cannot be read is left out and never charged.
- **Bloggers need no key and no login.** Give a blog ID or a blog link and the actor reads the blog's own post list, 30 posts a page, newest first, back to the first post (a 2009 post parsed as cleanly as one from this week). It opens only pages that blog.naver.com's robots.txt allows, checked on every URL.
- **Keyword search on Naver's official API, with your own free key.** Naver gives every application 25,000 free Search API calls a day, and one call returns up to 100 posts. Your Client ID and Secret are secret inputs, stored encrypted and never logged. A run without a key charges nothing for keywords.

[![Run it on Apify](https://api.apify.com/v2/key-value-stores/cUXz95yxflDho41nn/records/button-run.png)](https://console.apify.com/actors/H5fauUzxE2wiQVGf2/input)

**Part of The Mine Works Social media and video family:** [Threads Scraper](https://apify.com/themineworks/threads-scraper), [Reddit Scraper](https://apify.com/themineworks/reddit-scraper), [Threads Search Scraper](https://apify.com/themineworks/threads-search-scraper), [Instagram Profile Scraper](https://apify.com/themineworks/instagram-profile-scraper), [Instagram Followers & Following](https://apify.com/themineworks/instagram-followers-scraper), [Reddit Search Scraper](https://apify.com/themineworks/reddit-search-scraper).

### Try it in one minute

Paste this into the JSON tab of the input page. It returns the 10 newest posts of Naver's official blog with their full text, usually in about 10 seconds.

```json
{
  "bloggers": ["naverofficial"],
  "maxPostsPerBlogger": 10
}
```

You can give the actor two kinds of input, in any mix. `bloggers` takes a blog ID (`naverofficial`), a blog link (`https://blog.naver.com/naverofficial`, the `m.blog.naver.com` form works too) or a single post link (`https://blog.naver.com/naverofficial/224428038966`). `keywords` takes search words in Korean or English and needs your own Naver key in `naverClientId` and `naverClientSecret`. Everything else is optional.

Apify's free plan includes $5 of credit every month, which covers about 3,200 posts at this actor's Free tier price, counted for runs of 100 posts with the $0.005 start fee.

#### Copy to your AI assistant

```
themineworks/naver-blog-posts-scraper on Apify. Scrapes Naver Blog (네이버 블로그) posts with full text, either every post of the bloggers you name (no key needed) or keyword search through Naver's official Search API with your own free Client ID and Secret, and returns one row per post with title, exact publish time (KST), category, Naver topic, blog name, author nickname, comment count, full body text, image links, outbound links and thumbnail. Call ApifyClient("TOKEN").actor("themineworks/naver-blog-posts-scraper").call(run_input={...}), then client.dataset(run["defaultDatasetId"]).list_items().items. Required: at least one of bloggers (blog IDs, blog links or post links) or keywords (with naverClientId and naverClientSecret). Optional: maxPostsPerBlogger (default 20, max 6000), maxPostsPerKeyword (default 50, max 1100), sort ("sim" or "date", default "sim", keywords only), includeFullText (default true), postedWithinDays (no default), onlyNewPosts (default false). Skip rows with _type "info"; the run summary is the key-value store record OUTPUT. Full spec: GET https://api.apify.com/v2/acts/themineworks~naver-blog-posts-scraper/builds/default (Bearer TOKEN), which returns inputSchema and readme. Token: https://console.apify.com/account/integrations
```

### Key features

- **Up to 31 fields per post** (27 on a blogger's post): `title`, `published_at` (Korea time, to the second), `category_name`, `topic`, `blog_name`, `author_name`, `comment_count`, `content_text`, `content_chars`, `image_count`, `image_urls`, `video_count`, `link_urls`, `thumbnail_url`, the post and mobile links, and for keywords Naver's own `snippet`, `blogger_name` and `total_for_keyword`.
- **Two routes in one run**: up to 100 bloggers (up to 6,000 posts each) and up to 100 keywords (up to 1,099 results each, the deepest the Naver API serves).
- **Three editor generations parsed**: SmartEditor ONE (most posts since about 2018), SmartEditor 3 and the older SmartEditor 2 layout, so old archives come out as clean text too.
- **Date window**: `postedWithinDays` stops a blogger at the first older post and a newest first keyword search at the first page of older posts, so you do not pay to read what you will throw away.
- **Monitor mode**: `onlyNewPosts` returns only posts this input has not returned before and stops reading a blogger at the first list page with nothing new.
- **Plain HTTP at 256 MB**: no browser, Apify datacenter proxy included, at most 4 pages in flight so a run never bursts.

### How to use it

#### Basic: one blogger

```json
{
  "bloggers": ["https://blog.naver.com/naver_search"],
  "maxPostsPerBlogger": 20
}
```

The 20 newest public posts of the blog, each with its full text. The rank field is the post's place in the blog's list, 1 being the newest.

#### Several bloggers and keywords at once

```json
{
  "bloggers": ["naverofficial", "naver_search", "https://blog.naver.com/naverofficial/224419559395"],
  "keywords": ["제주 여행", "강남 맛집"],
  "naverClientId": "YOUR_CLIENT_ID",
  "naverClientSecret": "YOUR_CLIENT_SECRET",
  "maxPostsPerBlogger": 50,
  "maxPostsPerKeyword": 100
}
```

Bloggers, single post links and keywords run side by side. A post found twice (for example by a blogger and by a keyword) is delivered and charged once.

#### Influencer content audit: a blogger's whole archive

```json
{
  "bloggers": ["naverofficial"],
  "maxPostsPerBlogger": 3000
}
```

Every public post with its category, topic, comment count, body length and image count, ready to sort in a spreadsheet. For a quick inventory without the text, add `"includeFullText": false`: the run then reads only the list pages (30 posts each) and finishes in a fraction of the time.

#### Brand mention monitoring on keywords

```json
{
  "keywords": ["다이슨 에어랩", "dyson airwrap 후기"],
  "naverClientId": "YOUR_CLIENT_ID",
  "naverClientSecret": "YOUR_CLIENT_SECRET",
  "sort": "date",
  "postedWithinDays": 2,
  "onlyNewPosts": true
}
```

Save it as a task and schedule it daily (Console, the actor, Schedules). Each run asks Naver for the newest posts, stops at posts older than two days and returns only posts it has not returned before, each with its full text, so you read and pay for new mentions only.

#### Competitor blog watch

```json
{
  "bloggers": ["competitor_blog_id_1", "competitor_blog_id_2"],
  "onlyNewPosts": true,
  "maxPostsPerBlogger": 30
}
```

Schedule it weekly. The first run returns up to 30 posts per blog; later runs return only what was published since, and stop each blog at the first list page with nothing new.

#### Full text for a list of post links

```json
{
  "bloggers": [
    "https://blog.naver.com/naverofficial/224428038966",
    "https://m.blog.naver.com/naver_search/224419595054"
  ]
}
```

Each post link opens just that post. Use this when you already have links from somewhere else, for example a spreadsheet of sponsored posts to check.

### Input parameters

| Parameter | Type | Default | What it does |
| --- | --- | --- | --- |
| `bloggers` | array of strings | none | Blog IDs, blog links (`blog.naver.com` or `m.blog.naver.com`) or single post links. Up to 100 bloggers per run. No key needed. |
| `maxPostsPerBlogger` | integer | 20 | Most posts per blogger, newest first. 1 to 6,000. |
| `keywords` | array of strings | none | Searches for Naver's official Search API (blog). Needs your own key. Up to 100 per run. |
| `naverClientId` | string (secret) | none | Client ID of your own Naver application with the Search API added. Only for keywords. |
| `naverClientSecret` | string (secret) | none | Client Secret of the same application. Only for keywords. |
| `maxPostsPerKeyword` | integer | 50 | Most posts per keyword. 1 to 1,100 (the API serves ranks 1 to 1,099). |
| `sort` | string | `sim` | Keyword order: `sim` (relevance, 정확도순) or `date` (newest first, 최신순). Bloggers are always newest first. |
| `includeFullText` | boolean | `true` | Open each post's page for the full text, exact time, category, images and links. Off returns list data only. Post links always open the page. |
| `postedWithinDays` | integer | none | Keep only posts from the last N days. Older posts are never read further or charged. |
| `onlyNewPosts` | boolean | `false` | Return only posts this same input has not returned in an earlier run. |

### What data do you get?

One row per post. Fields are grouped below; a field the page or the API does not give is left out of that row rather than filled with a guess.

- **Where it came from**: `source` (`blogger`, `post` or `keyword`), `source_input` (the line you gave), `keyword`, `rank` (place in the blog's list or in Naver's results).
- **The post**: `blog_id`, `log_no`, `url`, `mobile_url`, `title`, `published_at` (Korea time, UTC+9, to the second), `published_date`, `date_precision` (`exact` from the post page, `day` from a list or API date, `approximate` when the list says "5시간 전").
- **Blog and author**: `blog_name`, `author_name` (the nickname shown on the post), `category_name` and `category_no` (the blogger's own category), `topic` (Naver's subject label such as 국내여행 or IT·컴퓨터, when the page gives one).
- **Body**: `content_text` (one line per paragraph), `content_chars`, `image_count`, `image_urls` (first 30), `video_count`, `link_urls` (first 30 outbound links), `thumbnail_url`, `snippet` (Naver's summary).
- **Engagement**: `comment_count`, when the blog shows it. Like (공감) counts are not in the pages this actor reads, so they are not returned.
- **Keyword rows only**: `blogger_name` and `blogger_link` as the Search API gives them, and `total_for_keyword` (Naver's total for the search).
- **Status**: `full_text_status` (`ok`, `off`, or `not_naver_blog` for a keyword result outside blog.naver.com, which keeps the API fields only), `scraped_at`.

#### Stable fields for automations

These fields were present in every post row of our proof runs, with full text on and off. We will not rename them.

| Field | What it holds |
| --- | --- |
| `source` | `blogger`, `post` or `keyword` |
| `source_input` | The input line the row came from |
| `rank` | Place in the blog's list (1 is newest) or in Naver's keyword results |
| `blog_id` | The blog ID, lower case |
| `log_no` | Naver's post number |
| `url` | `https://blog.naver.com/<blog_id>/<log_no>` |
| `mobile_url` | The same post on m.blog.naver.com |
| `title` | Post title |
| `published_date` | Publish date in Korea time, `YYYY-MM-DD` |
| `date_precision` | `exact`, `day` or `approximate` |
| `category_no` | The blogger's category number |
| `full_text_status` | `ok` when the full text was read, `off` when you turned it off |
| `scraped_at` | When the row was read, UTC |

With full text on, every proof row also carried `published_at`, `category_name`, `blog_name`, `author_name`, `content_text`, `content_chars`, `image_count`, `image_urls`, `video_count`, `link_urls`, `thumbnail_url` and `snippet`. `topic` was on 19 of 20 rows and `comment_count` on 9 of 20 (one of the two blogs hides comment counts).

#### Output examples

Real rows from our local runs on 1 Oct 2026, trimmed: long text and link lists are cut where you see `...`, and the second row leaves out fields the first one already shows.

A post from Naver's official blog, full text on:

```json
{
  "source": "blogger",
  "source_input": "naverofficial",
  "rank": 5,
  "blog_id": "naverofficial",
  "log_no": "224419559395",
  "url": "https://blog.naver.com/naverofficial/224419559395",
  "mobile_url": "https://m.blog.naver.com/naverofficial/224419559395",
  "title": "[네이버 메이트 인터뷰] 여행 블로그 '꿀멍트래블'을 만나다",
  "published_at": "2026-09-22T10:29:16+09:00",
  "published_date": "2026-09-22",
  "date_precision": "exact",
  "category_name": "네이버가 만난 사람들",
  "category_no": 124,
  "topic": "국내여행",
  "blog_name": "네이버 공식블로그",
  "author_name": "naverofficial",
  "comment_count": 46,
  "snippet": "네이버 메이트는 블로그·카페·지식iN·프리미엄 콘텐츠 등에서 활동하는 창작자와 커뮤니티를 매월 선정해 ...",
  "content_text": "네이버 메이트는 블로그·카페·지식iN·프리미엄 콘텐츠 등에서 활동하는\n창작자와 커뮤니티를 매월 선정해 함께 성장하는 콘텐츠 파트너 프로그램입니다.\n\n스페셜 메이트는 이달의 메이트로 선정된 크리에이터 가운데\n활발한 활동을 보여준 파트너를 말하는데요...",
  "content_chars": 9363,
  "image_count": 9,
  "image_urls": ["https://postfiles.pstatic.net/MjAyNjA5MjJfMjA0/MDAxNzkwMDQwMzQwNTgz.S2z--BglhXsofgwNopihxVcYly2LaK53nC3DmFM2Jwwg.c_tQnTk-2xe0es-DfMOLt6-_UwrvW6SMryu8IWlRQlUg.PNG/01.png?type=w966", "..."],
  "video_count": 0,
  "link_urls": [],
  "thumbnail_url": "https://blogthumb.pstatic.net/MjAyNjA5MjJfMTE3/MDAxNzkwMDQwNDg4MjM4.0XSnX3XoFdNuj0hIn4xkTMjTwBHX-4QEHqTN_6I-KUcg.samlR21nME7JzmvCXPDtyKFEXdGJpXP6gxCd18KmrLog.PNG/09.png?type=w2",
  "full_text_status": "ok",
  "scraped_at": "2026-10-01T09:00:01.375Z"
}
```

A post from Naver Search's blog, given as a blog link, with outbound links:

```json
{
  "source": "blogger",
  "source_input": "https://blog.naver.com/naver_search",
  "rank": 1,
  "blog_id": "naver_search",
  "log_no": "224419595054",
  "url": "https://blog.naver.com/naver_search/224419595054",
  "title": "AI 기술로 새로워진 해외여행 검색, 일본에 이어 아시아 주요 여행지로 확대됐습니다",
  "published_at": "2026-09-22T14:59:17+09:00",
  "published_date": "2026-09-22",
  "date_precision": "exact",
  "category_name": "서비스",
  "category_no": 44,
  "topic": "IT·컴퓨터",
  "blog_name": "NAVER Search & Tech",
  "author_name": "네이버 검색",
  "content_text": "안녕하세요, 네이버 플레이스 검색입니다.\n\n곧 다가오는 추석 연휴, 해외여행 계획하고 계신가요?\n일본에서 먼저 적용된 여행검색 개편이 (이전 공지 참고), 발리·나트랑·싱가포르·홍콩 등 아시아 주요 51개 여행지로 확대되었습니다...",
  "content_chars": 1163,
  "image_count": 4,
  "video_count": 0,
  "link_urls": ["https://blog.naver.com/naver_search/223812058736", "https://m.search.naver.com/search.naver?sm=mtb_hty.top&where=m&ssc=tab.m.all&query=%EB%B0%9C%EB%A6%AC", "..."],
  "full_text_status": "ok",
  "scraped_at": "2026-10-01T09:00:04.140Z"
}
```

The same post with `includeFullText` off (list data only, one list page for 30 posts):

```json
{
  "source": "blogger",
  "source_input": "naver_search",
  "rank": 1,
  "blog_id": "naver_search",
  "log_no": "224419595054",
  "url": "https://blog.naver.com/naver_search/224419595054",
  "mobile_url": "https://m.blog.naver.com/naver_search/224419595054",
  "title": "AI 기술로 새로워진 해외여행 검색, 일본에 이어 아시아 주요 여행지로 확대됐습니다",
  "published_date": "2026-09-22",
  "date_precision": "day",
  "category_no": 44,
  "full_text_status": "off",
  "scraped_at": "2026-10-01T09:00:18.798Z"
}
```

The one info row a run writes when it delivers nothing, here for a keyword run with a refused key (real answer from Naver to a fake key):

```json
{
  "_type": "info",
  "message": "The key was refused: NID AUTH Result Invalid (1000) : Authentication failed. (인증에 실패했습니다.) (HTTP 401, errorCode 024). Check the Client ID and Client Secret at developers.naver.com > Application. Nothing was charged.",
  "scraped_at": "2026-10-01T09:00:37.427Z"
}
```

That run was local, without pay per event. On Apify the message ends with "Only the $0.005 start fee was charged.", because the start fee is charged once a key is present, before the first call.

A keyword row has the same fields plus `keyword`, `blogger_name`, `blogger_link` and `total_for_keyword`, and its `snippet` is Naver's own search summary. We have no Naver key of our own, so no real keyword row is shown here; the keyword route is tested against Naver's documented answer format and Naver's real error answers.

### Pricing

Pay per event: you pay for each post delivered to your dataset, plus a flat $0.005 per run whatever memory you choose. The Naver Search API itself is free for your key, within 25,000 calls a day.

| Event | Free plan | Starter (Bronze) | Scale (Silver) | Business (Gold) and above |
| --- | --- | --- | --- | --- |
| Post delivered (`post-scraped`), per post | $0.00149 | $0.00145 | $0.00139 | $0.00129 |
| Run start (`run-start`), once per run | $0.005 | $0.005 | $0.005 | $0.005 |

So 1,000 posts cost 1,000 times the per post price of your plan, plus $0.005 for the run. The full text, the proxy, the paging and the cleanup are included; a post costs the same with full text on or off.

- **Start fee**: a flat $0.005 per run, charged after the input checks pass and before the first request. It does not grow with memory. A run that only has keywords and no key stops before it, so it costs nothing.
- **Never charged**: a post already delivered in the same run (one post found by two inputs), posts delivered in an earlier run when `onlyNewPosts` is on, posts outside `postedWithinDays`, posts whose page could not be read while full text is on, deleted or private posts, blogs that do not exist, refused or failed calls, and the `_type: "info"` row.
- **Spend cap**: set Apify's "Max cost per run" and the actor stops cleanly at what the cap pays for, with no free rows past it.

### FAQ

#### What is Naver Blog?

Naver Blog (네이버 블로그) is the blog platform of Naver, Korea's largest search portal. Korean shoppers read Naver blog reviews before they buy, so the posts are a core source for Korean product research, restaurant and travel reviews, influencer marketing and brand monitoring. This actor reads public posts on blog.naver.com.

#### Why do bloggers need no key, but keywords do?

For bloggers the actor reads two kinds of page that blog.naver.com's robots.txt allows: the blog's own post list and each post page. Naver's keyword search pages (search.naver.com, the blog section search and the mobile blog search and API paths) are disallowed for crawlers in robots.txt, so this actor does not scrape them. Keywords go through Naver's official Search API instead, which needs a key from the person running the search.

#### How do I get a Naver Search API key?

It is free. Sign in at developers.naver.com, open Application, then Register (애플리케이션 등록). Add the Search (검색) API, choose the WEB environment with any URL, and save. Copy the Client ID and Client Secret into `naverClientId` and `naverClientSecret`. One application gets 25,000 calls a day; one call returns up to 100 posts. Every buyer uses their own key: the actor never falls back to a key of ours.

#### Is my key safe?

Both key fields are secret inputs, which Apify stores encrypted. The key travels only in the two request headers Naver asks for, to openapi.naver.com and nowhere else. It is never written to the log, the dataset or the run summary; any error text is scrubbed of it before it is logged.

#### What happens if my key is wrong, or I give none?

With no key, keywords are skipped: a keywords only run stops at once with a message on how to get a key and charges nothing, and a run that also has bloggers reads the bloggers and reports the keywords as skipped. With a refused key (HTTP 401 or 403), the actor makes one call, stops the keyword search cleanly and writes Naver's own message, for example "NID AUTH Result Invalid (1000)", to the status and the run summary. Bloggers in the same run still run. When Naver says the key's daily limit is used up (HTTP 429), the actor waits twice and then stops the keyword search with a clear message.

#### How many posts can I get?

Per blogger, up to 6,000 posts, newest first (the blog's own list, 30 a page). Per keyword, up to 1,099 results, the deepest the Naver Search API serves for one search and one sort order; a second run with the other `sort` reaches a different set. One run reads up to about 60,000 posts with full text before its cost ceiling stops it; split bigger jobs into several runs.

#### How fresh is the data?

Every run reads live pages and live API answers; nothing is cached. `published_at` comes from the post page itself and is exact to the second in Korea time. Without full text, the date comes from the list ("2026. 9. 23.", or "5시간 전" for posts from the last day, which the actor turns into an approximate time).

#### Do I need a Naver account, cookies or a proxy?

No account and no cookies: the actor reads public pages as an anonymous visitor (blog.naver.com sets the same anonymous session cookie for every visitor). The Apify datacenter proxy is used automatically and is included in the price. Private, members only and deleted posts are not readable without a login, so they are skipped and not charged.

#### Why did I get fewer posts than I asked for?

The usual reasons, each counted per input in the run summary (the OUTPUT record): the blog has fewer public posts, `postedWithinDays` cut the list, `onlyNewPosts` skipped posts returned before, a post was deleted or made private, or a post page could not be read after three tries (left out and not charged). For keywords, Naver's total may be smaller than your limit.

#### Can I run it on a schedule to monitor bloggers or keywords?

Yes. Save the input as a task, turn on `onlyNewPosts`, and add a schedule in Apify Console. Each run then returns only new posts. For keywords, `"sort": "date"` with `postedWithinDays` keeps each run short.

#### Can I use the posts to train an AI model or feed a RAG system?

Read this before you do. Naver's robots.txt for blog.naver.com says, in Naver's words, "BOT ACCESS FOR THE PURPOSES OF AI TRAINING AND RETRIEVAL-AUGMENTED GENERATION (RAG) IS STRICTLY PROHIBITED", and it disallows every page to AI crawlers such as GPTBot, ClaudeBot, CCBot and Google-Extended. This actor follows the rules for general crawlers (`User-agent: *`) and opens only pages those rules allow, but what you do with the data is your decision and your responsibility. If your use is AI training or retrieval augmented generation, Naver says it prohibits that.

#### Can I use it from Claude, ChatGPT or another AI assistant?

- Connector URL: `https://mcp.apify.com/?tools=themineworks/naver-blog-posts-scraper`.
- Claude: Settings > Connectors > Add custom connector, paste the URL, sign in with Apify.
- ChatGPT: developer mode, add an MCP connector with the URL, sign in with Apify.
- Cursor or VS Code: add it as an HTTP MCP server with that URL.
- Claude Code: `claude mcp add -t http naver-blog-posts-scraper "https://mcp.apify.com/?tools=themineworks/naver-blog-posts-scraper"`.

#### Is it legal to scrape Naver Blog?

The actor collects public posts only, with no login, and it follows blog.naver.com's robots.txt for general crawlers. Posts are written by people, so they can contain personal data and are protected by copyright. You are responsible for how you use the data, including Naver's terms, copyright, and data protection laws such as Korea's PIPA, the GDPR and the CCPA. If in doubt, ask a lawyer.

### Integrations

- **Google Sheets, Excel, CSV, JSON**: export the dataset from the run page, or link a Google Sheet with Apify's Google Sheets integration. The "Posts" view gives a one line per post table; the "Full text" view adds the body.
- **Make, Zapier, n8n**: use the Apify app to start a run and pick up the posts when it finishes.
- **Webhooks**: get a call to your own endpoint when a run succeeds or fails.
- **API**: start runs and read results with the Apify API or the `apify-client` package for Python and JavaScript.
- **MCP clients**: Claude, ChatGPT, Cursor and other MCP clients can call the actor through Apify's MCP server.

### More from The Mine Works

**Social media and video**

- [Threads Scraper](https://apify.com/themineworks/threads-scraper)
- [Reddit Scraper](https://apify.com/themineworks/reddit-scraper)
- [Threads Search Scraper](https://apify.com/themineworks/threads-search-scraper)
- [Instagram Profile Scraper](https://apify.com/themineworks/instagram-profile-scraper)
- [Instagram Followers & Following](https://apify.com/themineworks/instagram-followers-scraper)
- [Reddit Search Scraper](https://apify.com/themineworks/reddit-search-scraper)
- [Twitter / X Scraper](https://apify.com/themineworks/twitter-x-scraper)
- [Xiaohongshu (RED) Scraper](https://apify.com/themineworks/xiaohongshu-explore-scraper)
- [YouTube Transcript](https://apify.com/themineworks/youtube-transcript-scraper)
- [Telegram Channel Scraper](https://apify.com/themineworks/telegram-channel-scraper)
- [Telegram Channel Finder](https://apify.com/themineworks/telegram-channel-finder)
- [Pinterest Profile Scraper](https://apify.com/themineworks/pinterest-profile-scraper)

**Leads and business directories**

- [B2B Leads Finder](https://apify.com/themineworks/b2b-leads-finder)
- [Skip Trace Lookup](https://apify.com/themineworks/skip-trace-lookup)
- [Google Maps Email Scraper](https://apify.com/themineworks/maps-leads)
- [JustDial Scraper](https://apify.com/themineworks/justdial-business)

**Marketing, SEO and reviews**

- [Facebook Ad Library Scraper](https://apify.com/themineworks/meta-ad-library-scraper)
- [Similarweb Scraper](https://apify.com/themineworks/similarweb-scraper)
- [Google Ads Transparency Scraper](https://apify.com/themineworks/google-ads-transparency)
- [Google News Scraper](https://apify.com/themineworks/google-news)

**LinkedIn**

- [LinkedIn Company Scraper](https://apify.com/themineworks/linkedin-company-details)
- [LinkedIn Post Scraper](https://apify.com/themineworks/linkedin-post-search)
- [LinkedIn Employees Scraper](https://apify.com/themineworks/linkedin-employees)
- [LinkedIn Profile Scraper](https://apify.com/themineworks/linkedin-profile-scraper)

**Real estate**

- [Zillow Rentals Scraper](https://apify.com/themineworks/zillow-rental-listings)
- [Zillow Sold Comps Scraper](https://apify.com/themineworks/zillow-recently-sold)
- [Housing.com Scraper](https://apify.com/themineworks/housing-com-scraper)
- [India Real Estate MCP](https://apify.com/themineworks/india-real-estate-mcp)

**Science, health and government data**

- [CourtListener Scraper](https://apify.com/themineworks/courtlistener-court-records)
- [data.gov.in Scraper](https://apify.com/themineworks/india-data-gov-scraper)
- [Socrata Open Data Scraper](https://apify.com/themineworks/socrata-open-data)
- [Academic Research MCP](https://apify.com/themineworks/academic-research-mcp)

**Jobs and hiring**

- [Foundit Monster India Jobs](https://apify.com/themineworks/foundit-jobs-scraper)
- [Hirist Jobs Scraper](https://apify.com/themineworks/hirist-jobs-scraper)
- [India Jobs MCP](https://apify.com/themineworks/india-jobs-mcp)
- [Naukri Jobs Scraper](https://apify.com/themineworks/naukri-jobs)

**E-commerce and marketplaces**

- [Ozon.ru Scraper](https://apify.com/themineworks/ozon-product-search)
- [⭐ Amazon Reviews Scraper](https://apify.com/themineworks/amazon-reviews)
- [Amazon Product Scraper](https://apify.com/themineworks/amazon-products)
- [Carsales.com.au Scraper](https://apify.com/themineworks/carsales-scraper)

**Company and business data**

- [Company Domain Finder](https://apify.com/themineworks/company-domain-finder)
- [GST Taxpayer Lookup](https://apify.com/themineworks/gst-taxpayer-lookup)
- [World Bank Trade Scraper](https://apify.com/themineworks/global-trade-data)
- [Company KYB Resolver](https://apify.com/themineworks/company-identity-resolver)

**Food and local services**

- [NoBroker Scraper](https://apify.com/themineworks/nobroker-scraper)
- [Swiggy Restaurant Scraper](https://apify.com/themineworks/swiggy-scraper)
- [Zomato Scraper](https://apify.com/themineworks/zomato-scraper)

**Developer and AI tools**

- [Website to Markdown Crawler](https://apify.com/themineworks/rag-crawler)
- [GitHub Skill Finder](https://apify.com/themineworks/github-skill-discovery)
- [GitHub Repo Scraper](https://apify.com/themineworks/github-repo-intelligence)
- [GitHub Trending Scraper](https://apify.com/themineworks/github-trending-scraper)

**More tools**

- [Tennis Match & Player Data Scraper](https://apify.com/themineworks/tennis-match-data)
- [Google Hotels Prices Scraper](https://apify.com/themineworks/google-hotels-prices-scraper)
- [LandWatch Scraper](https://apify.com/themineworks/landwatch-land-for-sale-scraper)

### Support

Found a problem or need a field we do not return? Open an issue on the actor's Issues tab and we will answer there. To ask for a new source, email dmineworks@gmail.com.

*Naver Blog Scraper turns Naver bloggers and keywords into clean rows of full post text, with exact dates and no charge for anything it cannot deliver.*

# Actor input Schema

## `bloggers` (type: `array`):

One per line: a blogger ID (naverofficial), a blog link (https://blog.naver.com/naverofficial, m.blog.naver.com works too) or a single post link (https://blog.naver.com/naverofficial/224428038966). Each blogger's posts come newest first. No key needed. Up to 100 bloggers per run.

## `maxPostsPerBlogger` (type: `integer`):

Most posts to return for each blogger, newest first. The blog's own list shows 30 posts a page, so 6,000 is 200 pages.

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

One search per line, in Korean or English (강남 맛집, 제주도 여행, dyson). Searched through Naver's official Search API (blog), so it needs your own Naver key below. Up to 100 per run.

## `naverClientId` (type: `string`):

Client ID of your own Naver application. Free: sign in at developers.naver.com, open Application > Register (애플리케이션 등록), add the Search (검색) API, choose the WEB environment with any URL, then copy the Client ID. Stored encrypted; never logged or written to the output. Only needed for keywords.

## `naverClientSecret` (type: `string`):

Client Secret of the same Naver application. Stored encrypted; never logged or written to the output.

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

Most posts to return for each keyword. The API serves ranks 1 to 1,099 of any search; every 100 results is one call on your key (25,000 free calls a day).

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

The order Naver ranks keyword results in. Newest first suits daily monitoring. Bloggers are always newest first.

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

Opens each post's page for the full body text, exact publish time, category, images, links and comment count (one extra page per post). Off returns the list data only: title, date, link and, for keywords, Naver's snippet. With full text on, a post whose page cannot be read is left out and not charged. Post links always open the page.

## `postedWithinDays` (type: `integer`):

Leave empty for every post. For bloggers the list stops at the first older post; for keywords sorted newest first the search stops at the first page of older posts. Older posts are never charged.

## `onlyNewPosts` (type: `boolean`):

For scheduled runs. Returns only posts this same input has not returned in an earlier run, and stops reading a blogger at the first list page with nothing new. The first run returns everything. The memory is kept in a key-value store in your account named after this input.

## Actor input object example

```json
{
  "bloggers": [
    "naverofficial"
  ],
  "maxPostsPerBlogger": 20,
  "maxPostsPerKeyword": 50,
  "sort": "sim",
  "includeFullText": true,
  "onlyNewPosts": false
}
```

# Actor output Schema

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

No description

## `summary` (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 = {
    "bloggers": [
        "naverofficial"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/naver-blog-posts-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 = { "bloggers": ["naverofficial"] }

# Run the Actor and wait for it to finish
run = client.actor("themineworks/naver-blog-posts-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 '{
  "bloggers": [
    "naverofficial"
  ]
}' |
apify call themineworks/naver-blog-posts-scraper --silent --output-dataset

```

## MCP server setup

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