# Naver Blog Post Search & Full Content Extractor (`nimbryxo-studio/naver-blog-post-search-and-full-content-extractor`) Actor

Search Naver Blog by keyword, fetch recent posts from a specific blog, or get full post content and tags, with author, blog name, publish date and URLs.

- **URL**: https://apify.com/nimbryxo-studio/naver-blog-post-search-and-full-content-extractor.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Social media, News, SEO tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Post Search & Full Content Extractor

Naver Blog is South Korea's largest blogging platform, and its posts hold first-hand reviews, local guides, recipes, and daily-life writing that rarely appear elsewhere. This actor searches Naver Blog by keyword, walks an entire public blog archive, or fetches a list of post URLs — returning clean post records with exact publish times, full text, images, tags, categories, and places.

No Naver account, login, API key, or proxy setup is required.

### What this actor does

- **Three modes:** `search` for keyword discovery, `blogPosts` for a blog's public archive, and `postDetails` for exact URLs.
- **Multiple targets per run:** search up to 50 keywords and read up to 50 blog IDs in one run, with duplicates removed across queries.
- **Real sorting and date filters:** relevance or newest-first, plus last hour/day/week/month/3 months/6 months/year and custom `YYYY-MM-DD` ranges.
- **Full posts, not snippets:** optional content enrichment adds the complete body, exact publish time, images, thumbnail, tags, category, and Naver Map places.
- **Exact publish times:** `publishedAt` is the post's real timestamp in Korea Standard Time (UTC+9), while `publishDateText` preserves what Naver displayed.
- **Reactions and comments:** like counts, reaction breakdowns, and optional comment counts and paginated comment threads (up to `maxComments` per post).
- **Empty fields are omitted:** every record is cleaned recursively, so absent data is never returned as `null`, `""`, or `[]`.

### Output per post

| Field | Description |
|---|---|
| `title` | Post title, HTML removed |
| `summary` | Search snippet or the post page's description |
| `authorName` | Author's display name |
| `authorUrl` | Author profile link, when Naver exposes one |
| `blogName` | Name of the blog |
| `blogId` | Blog identifier, e.g. `travel_lover` |
| `blogUrl` | Blog home URL |
| `postUrl` | Canonical post URL |
| `publishDate` | Publish date in `YYYY-MM-DD` format (KST) |
| `publishedAt` | Exact publish time as ISO 8601 with `+09:00` (content enrichment only) |
| `publishDateText` | Date as Naver displayed it, e.g. `2주 전` or `2026. 10. 23. 11:10` |
| `category` | Blog category name (content enrichment only) |
| `tags` | Hashtags found on the post (content enrichment only) |
| `images` | Full-size content image URLs (content enrichment only) |
| `imageCount` | Number of images in `images` |
| `thumbnail` | Representative image for the post |
| `places` | Naver Map places mentioned in the post (content enrichment only) |
| `hasVideo` | `true` when the post contains a video (only present when true) |
| `isSelfPurchased` | `true` when Naver shows its structured self-purchased review disclosure (내돈내산) |
| `content` | Complete post text, never truncated (content enrichment only) |
| `contentHtml` | Post body HTML, only when `includeHtml` is on |
| `contentLength` | Character count of `content` |
| `rank` | 1-based organic position for the query that found the post (`search` only) |
| `searchQuery` | First query that found the post (`search` only) |
| `matchedQueries` | Every processed query that found the post (`search` only) |
| `commentCount` | Total comments including replies; from the blog list or `includeComments` |
| `comments` | Comment threads up to `maxComments` (default 100), fetched in pages of 100, only when `includeComments` is on |
| `likeCount` | Main "like" (공감) count when Naver publishes it (content enrichment only) |
| `reactionCounts` | Counts by reaction type (`like`, `impressive`, `thanks`, `wow`, `haha`, `sad`) when Naver publishes them |
| `recordType` | Always `"blogPost"` |
| `scrapedAt` | UTC timestamp when the record was scraped |

Each place in `places` contains `name`, `address`, `latitude`, `longitude`, `phone`, `placeId`, and `bookingUrl`, with empty values omitted.

With `includeContent` off, search and blog-archive records contain list-level fields only: title, summary, author, blog, URLs, `publishDateText`, and the date when Naver shows an absolute date. `postDetails` always fetches the post page because that is the mode's purpose.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string (required) | `search` | `search`, `blogPosts`, or `postDetails` |
| `searchQueries` | array of strings | `["제주도 여행"]` | Keywords to search (mode=search); max 50 |
| `blogIds` | array of strings | – | Blog IDs or blog URLs (mode=blogPosts); max 50 |
| `postUrls` | array of strings | – | Post URLs to fetch (mode=postDetails); desktop, mobile, PostView, or `blogId/logNo` |
| `sortBy` | string | `sim` | `sim` for relevance, `date` for newest first (mode=search) |
| `publishedWithin` | string | `all` | `all`, `1h`, `1d`, `1w`, `1m`, `3m`, `6m`, `1y`, or `custom` (mode=search) |
| `dateFrom` | string | – | Start date `YYYY-MM-DD` for a custom range (mode=search) |
| `dateTo` | string | – | End date `YYYY-MM-DD` for a custom range (mode=search) |
| `categoryNo` | integer | `0` | Blog category number; `0` means every category (mode=blogPosts) |
| `maxItems` | integer | `20` | Hard cap on emitted records across all targets (1–10,000) |
| `includeContent` | boolean | `true` | Fetch each post page for full text and detail fields |
| `includeHtml` | boolean | `false` | Add `contentHtml`; turns content enrichment on |
| `includeComments` | boolean | `false` | Add `commentCount` and comment threads up to `maxComments`; turns content enrichment on |
| `maxComments` | integer | `100` | Maximum comments returned per post with `includeComments` (1–1,000) |
| `maxConcurrency` | integer | `3` | Parallel post-page requests when enriching content |

#### Example: Korean keyword search, newest first

```json
{
  "mode": "search",
  "searchQueries": ["제주도 여행"],
  "sortBy": "date",
  "publishedWithin": "all",
  "maxItems": 50,
  "includeContent": true
}
```

#### Example: several queries with a custom date range

```json
{
  "mode": "search",
  "searchQueries": ["K-beauty routine", "올리브영 추천"],
  "sortBy": "sim",
  "publishedWithin": "custom",
  "dateFrom": "2026-01-01",
  "dateTo": "2026-03-31",
  "maxItems": 200,
  "includeContent": false
}
```

#### Example: a blog's full archive in one category

```json
{
  "mode": "blogPosts",
  "blogIds": ["ranto28"],
  "categoryNo": 17,
  "maxItems": 500,
  "includeContent": true,
  "includeHtml": false
}
```

#### Example: full details for known posts

```json
{
  "mode": "postDetails",
  "postUrls": [
    "https://blog.naver.com/e_s_l/224451062514",
    "https://m.blog.naver.com/ranto28/224461024209",
    "https://blog.naver.com/PostView.naver?blogId=hoyaaaaa-&logNo=224458179821"
  ]
}
```

### Search limits and blog archives

Naver returns at most **1,000 posts per keyword search**. This is a source-side ceiling, not an actor setting. To collect more:

- split a broad topic into narrower queries;
- use `publishedWithin` presets or a custom `dateFrom`/`dateTo` window and run several windows;
- deduplicate with `postUrl` — the actor already removes duplicates inside a run.

Blog archives use a different source and are **not limited to 1,000 posts**: a public blog with 2,700 posts can return all 2,700. Search results are likely to repeat across pages, so deduplication is applied by canonical post URL.

Comment counts are included when Naver exposes them: from the blog list in `blogPosts` mode, or from the post page when `includeComments` is on. Likes (`likeCount` and `reactionCounts`) come from Naver's public reaction service and are omitted for posts with no reactions. With `includeComments`, `comments` returns up to `maxComments` per post (default 100, fetched in pages of 100) including replies when Naver returns them; `commentCount` is always the full total, so a post can have more comments than rows in `comments`.

#### Limitations

- **Search ceiling:** Naver accepts search start positions up to 1,000, so one query exposes roughly a 1,000-result window; after deduplication a run can return fewer. Split by date or query for more.
- **Comment cap:** Naver serves comment pages cookielessly; the actor pages through them up to `maxComments` per post (default 100, max 1,000) to keep output and request cost bounded. `commentCount` still reports the full total. Increase the cap if you need more rows. Posts with comments disabled return neither field.
- **Not shipped (scope decisions, not source limits):** blogger profile totals (neighbors, visitors, post count), cafe/news article search, paid-sponsorship classification, and incremental only-new state. Profile and cafe/news data are reachable on separate Naver surfaces but are outside this post-oriented actor; paid sponsorship has no ground-truth label and remains a text heuristic for users; incremental state is an implementation choice, and date windows plus `postUrl` dedupe cover the same workflow. Self-purchased reviews are labeled by Naver and are exposed as `isSelfPurchased`.
- **Private, deleted, or members-only posts** are skipped; one bad post does not fail the run.
- **Search relevance** is Naver's own ranking, including Korean results for English queries; the actor does not re-rank.
- **Markup changes:** Naver redesigns can require a parser update. The actor ships fixtures and status messages instead of failing silently.

### Use cases

- **Consumer research** — collect how Korean bloggers describe a product, brand, or store before a launch.
- **Influencer and blog discovery** — find active blogs in K-beauty, food, travel, parenting, or finance.
- **Brand monitoring** — track mentions across the Korean blogosphere, then filter by exact publish date.
- **Content and trend analysis** — measure post volume and topic shifts across date windows.
- **Local travel research** — gather first-hand restaurant, cafe, and itinerary write-ups with mapped places.
- **Archive and migration** — export a public blog's full post history, including text and image URLs.

### FAQ

**Do I need a Naver account or API key?**
No. The actor reads public Naver Blog pages. There is no login, key, or proxy configuration to provide.

**Can I search in Korean and English?**
Yes. Korean, English, and mixed queries all work. Results are mostly Korean-language blogs because that is what Naver Blog contains.

**How do I find a blog ID?**
Use the segment right after `blog.naver.com/`. For `https://blog.naver.com/travel_lover`, the blog ID is `travel_lover`. The actor also accepts the full blog URL or `@travel_lover`.

**Why do some posts have no `content`, `images`, or `publishedAt`?**
Those fields come from the post page, so they require `includeContent`. They are also omitted for empty-body posts, private or deleted posts, and text-only posts with no images or places.

**What is the difference between `publishDate` and `publishedAt`?**
`publishDate` is the date in `YYYY-MM-DD` format. `publishedAt` is the exact timestamp with a `+09:00` offset. `publishDateText` keeps the original wording, which may be relative such as `3일 전`.

**Why did a keyword return fewer posts than expected?**
Naver caps one keyword at 1,000 results and may return fewer for narrow queries. Add more queries or split the period into smaller date windows.

**Why are there no likes or comments on some posts?**
Naver's reaction and comment services are public but conditional: posts with no reactions omit `likeCount`/`reactionCounts`, and posts with comments disabled omit `commentCount`/`comments`. Set `includeComments=true` to request comments; `commentCount` is the total and `comments` holds up to `maxComments` rows (default 100, paginated 100 at a time).

**What does `isSelfPurchased` mean?**
It is `true` only when Naver itself shows the structured self-purchased review disclosure (내돈내산) on the post. It is not a paid-sponsorship classifier; `협찬`/`광고` wording remains in `content` for your own rules.

**What happens to private, deleted, or blocked posts?**
They are skipped with a log message. One missing post does not fail the run. If every target is invalid, the run finishes with a status message explaining what to check.

**Can I fetch more than 10,000 posts?**
`maxItems` is capped at 10,000 per run. For larger archives, split the work into separate runs and deduplicate by `postUrl`.

**Is this affiliated with Naver?**
No. This is an independent third-party actor that reads public Naver Blog pages. It is not affiliated with, endorsed by, or sponsored by Naver Corporation.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `searchQueries` (type: `array`):

One or more Korean or English keywords to search across Naver Blog (mode=search). Each query is searched up to Naver's 1,000-result limit.

## `blogIds` (type: `array`):

Naver blog IDs or blog URLs (mode=blogPosts). Accepts `hello_world123`, `@hello_world123`, or `https://blog.naver.com/hello_world123`.

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

Naver blog post URLs to fetch in detail (mode=postDetails). Accepts desktop, mobile, PostView, and bare `blogId/logNo` forms.

## `sortBy` (type: `string`):

Sort order for keyword search (mode=search).

## `publishedWithin` (type: `string`):

Limit keyword search results by publish period (mode=search). Choose Custom to use dateFrom and dateTo.

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

Start date in YYYY-MM-DD format (KST). Used when publishedWithin=custom (mode=search).

## `dateTo` (type: `string`):

End date in YYYY-MM-DD format (KST). Used when publishedWithin=custom (mode=search).

## `categoryNo` (type: `integer`):

Naver blog category number to restrict a blog archive; 0 means all categories (mode=blogPosts).

## `maxItems` (type: `integer`):

Hard cap on emitted records across all queries, blogs, or URLs.

## `includeContent` (type: `boolean`):

Fetch each post page for full text, exact publish time, images, tags, category, and places. Turn off for faster list-level records.

## `includeComments` (type: `boolean`):

Add the comment count and comment threads up to maxComments (default 100), including replies when Naver returns them. Implies includeContent=true and adds requests per post.

## `maxComments` (type: `integer`):

Maximum comments to return per post when includeComments is on. Fetched in pages of 100; commentCount still reports the full total.

## `includeHtml` (type: `boolean`):

Add the post body as HTML in contentHtml. Implies includeContent=true.

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

Parallel post-page requests when content enrichment is enabled.

## Actor input object example

```json
{
  "mode": "search",
  "searchQueries": [
    "제주도 여행"
  ],
  "blogIds": [],
  "postUrls": [],
  "sortBy": "sim",
  "publishedWithin": "all",
  "categoryNo": 0,
  "maxItems": 3,
  "includeContent": false,
  "includeComments": false,
  "maxComments": 100,
  "includeHtml": false,
  "maxConcurrency": 3
}
```

# Actor output Schema

## `blogPosts` (type: `string`):

Dataset containing all scraped Naver Blog posts.

# 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 = {
    "mode": "search",
    "searchQueries": [
        "제주도 여행"
    ],
    "blogIds": [],
    "postUrls": [],
    "sortBy": "sim",
    "publishedWithin": "all",
    "categoryNo": 0,
    "maxItems": 3,
    "includeContent": false,
    "includeComments": false,
    "maxComments": 100,
    "includeHtml": false,
    "maxConcurrency": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/naver-blog-post-search-and-full-content-extractor").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 = {
    "mode": "search",
    "searchQueries": ["제주도 여행"],
    "blogIds": [],
    "postUrls": [],
    "sortBy": "sim",
    "publishedWithin": "all",
    "categoryNo": 0,
    "maxItems": 3,
    "includeContent": False,
    "includeComments": False,
    "maxComments": 100,
    "includeHtml": False,
    "maxConcurrency": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/naver-blog-post-search-and-full-content-extractor").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 '{
  "mode": "search",
  "searchQueries": [
    "제주도 여행"
  ],
  "blogIds": [],
  "postUrls": [],
  "sortBy": "sim",
  "publishedWithin": "all",
  "categoryNo": 0,
  "maxItems": 3,
  "includeContent": false,
  "includeComments": false,
  "maxComments": 100,
  "includeHtml": false,
  "maxConcurrency": 3
}' |
apify call nimbryxo-studio/naver-blog-post-search-and-full-content-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/naver-blog-post-search-and-full-content-extractor"
        }
    }
}
```

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/JR9iN0YMYQXCfKan9/builds/EaLLw7aAkioCzX4Kt/openapi.json