# Naver Scraper — Blog & Knowledge-iN Search (Keyless) (`logiover/naver-scraper`) Actor

Scrape Naver Blog & Naver Knowledge-iN (지식iN) search results by keyword. Extract post/question title, URL, snippet, blogger, date, thumbnails & hashtags. 500+ results per run. No API key, no login.

- **URL**: https://apify.com/logiover/naver-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Naver Scraper — Blog & Knowledge-iN Search Data (Keyless)

Scrape **Naver Blog** posts and **Naver Knowledge-iN (지식iN)** questions & answers by keyword — no API key, no login, no cookies. Get clean, structured JSON with titles, URLs, snippets, blogger leads, publish dates, thumbnails and hashtags, and export **500+ results per run** to CSV, Excel, JSON or Google Sheets.

> Naver is South Korea's dominant search portal and content ecosystem. If you do Korean market research, SEO, influencer discovery or social listening, Naver Blog and Knowledge-iN are where the conversations actually happen — and this actor turns them into a spreadsheet.

***

### What does Naver Scraper do?

Naver Scraper collects search results from two public, keyless Naver surfaces through a simple mode switch:

- **Naver Blog search** — it calls the same JSON endpoint the Naver Blog section UI uses (`section.blog.naver.com/ajax/SearchList.naver`), returning up to 30 posts per page. The scraper paginates deep and fans out over one or more of your search terms, deduping by post URL until it hits your result target. For every post you get the title, post URL, a content snippet, the blogger's nickname, blog name and profile image, the publish date, thumbnails, and a "sponsored/marketing post" flag.
- **Naver Knowledge-iN (지식iN) search** — it parses the server-rendered Q\&A search result list on `kin.naver.com`, extracting each question's title, URL, snippet, date and hashtags.

Everything runs over plain HTTP with rotating proxies, so there is nothing to authenticate and no browser to babysit. Each row is tagged with the `query` it came from, the `_mode`, and an ISO `scrapedAt` timestamp.

***

### Who is it for?

- **SEO & content marketers** researching what ranks in Naver Blog for their target Korean keywords.
- **Influencer & PR teams** building lists of active Naver bloggers (name, blog URL, profile) in a niche.
- **Market researchers & analysts** tracking product mentions, reviews and sentiment in the Korean market.
- **E-commerce & brand teams** monitoring how their products (and competitors') appear across Naver Blog and Q\&A.
- **Developers & data teams** who need a reliable, keyless Naver data feed to plug into dashboards, warehouses or AI agents.

***

### Use cases

- **Keyword content audit** — pull the top 500 Naver Blog posts for "제주도 여행" (Jeju travel) and see who's writing, how often, and about what.
- **Influencer discovery** — collect blogger nicknames, blog names and blog URLs for a niche keyword to build outreach lists.
- **Sponsored-post detection** — use the `isSponsored` flag to separate organic reviews from paid/marketing posts.
- **Voice-of-customer & FAQ mining** — scrape Knowledge-iN questions for a product to learn the real questions Korean shoppers ask before buying.
- **Trend & recency tracking** — sort Blog results by newest first and re-run on a schedule to watch a topic evolve.

***

### Why use Naver Scraper?

- **100% keyless** — no Naver Developers app, no client ID/secret, no login, no cookies. Just enter a keyword and press Start.
- **Two Naver surfaces in one actor** — Naver Blog and Knowledge-iN, switchable via a single dropdown.
- **Built for volume** — deep pagination plus multi-query fan-out reliably yields **500+ rich rows per run** (up to 20,000).
- **Clean, typed output** — HTML highlight tags stripped, dates normalised to ISO, booleans as booleans, blogger lead fields ready for CRM/outreach.
- **Cheap & fast** — pure HTTP (no headless browser), so it runs on 512 MB with datacenter proxies.
- **Pay per result** — you only pay for the rows you actually get, exportable to CSV, JSON, Excel, or straight into Google Sheets.

***

### What data can you extract?

Every run produces a flat, spreadsheet-friendly dataset. Blog rows and Knowledge-iN rows share common fields (`title`, `url`, `contentSnippet`, `query`, `scrapedAt`) and add surface-specific fields.

| Field | Type | Description |
|-------|------|-------------|
| `title` | string | Post / question title (clean, tags stripped) |
| `url` | string | Public URL of the post / question |
| `contentSnippet` | string | Short content preview |
| `bloggerName` | string | Blog author nickname (blog mode) |
| `blogName` | string | Blog title (blog mode) |
| `blogUrl` | string | Blogger home URL — a ready outreach lead (blog mode) |
| `profileImageUrl` | string | Blogger profile image URL (blog mode) |
| `publishedAt` | string (ISO) | Post publish datetime (blog mode) |
| `publishedTimestamp` | number | Publish time in epoch ms (blog mode) |
| `thumbnail` | string | First thumbnail image URL (blog mode) |
| `thumbnails` | array | All thumbnail image URLs (blog mode) |
| `hasThumbnail` | boolean | Whether the post has a thumbnail |
| `isSponsored` | boolean | Whether it's a marketing/sponsored post |
| `buyWithOwnMoney` | boolean | Naver "bought with my own money" review badge |
| `blogId` | string | Naver blog ID |
| `postId` | string | Naver blog post ID (logNo) |
| `questionId` | string | Knowledge-iN docId (kin mode) |
| `dirId` | string | Knowledge-iN directory/category ID (kin mode) |
| `dateText` | string | Q\&A date as displayed (kin mode) |
| `date` | string | Q\&A date normalised to YYYY-MM-DD when parseable (kin mode) |
| `tags` | array | Hashtags on the Q\&A (kin mode) |
| `query` | string | Search term this row came from |
| `_mode` | string | `blog` or `kin` |
| `scrapedAt` | string (ISO) | Scrape timestamp |

#### Example output (Naver Blog)

```json
{
  "postId": "224343987841",
  "blogId": "ssoyeon_yoon",
  "title": "제주시 가볼만한곳 베스트 9",
  "url": "https://blog.naver.com/ssoyeon_yoon/224343987841",
  "contentSnippet": "제주 여행에서 꼭 가봐야 할 명소를 정리했어요 ...",
  "bloggerName": "제주소연",
  "blogName": "제주소연 ❤️",
  "blogUrl": "https://blog.naver.com/ssoyeon_yoon",
  "profileImageUrl": "https://blogpfthumb-phinf.pstatic.net/...",
  "publishedAt": "2026-07-10T05:46:00.000Z",
  "publishedTimestamp": 1783820760000,
  "thumbnail": "https://blogthumb.pstatic.net/...",
  "thumbnails": ["https://blogthumb.pstatic.net/...", "..."],
  "hasThumbnail": true,
  "isSponsored": false,
  "buyWithOwnMoney": false,
  "query": "제주도 여행",
  "_mode": "blog",
  "scrapedAt": "2026-07-25T09:12:31.004Z"
}
```

***

### How to use

#### Option A — Scrape Naver Blog (default)

1. Set **Mode** to *Naver Blog*.
2. Add one or more **Search terms** (Korean or any language), e.g. `강남 맛집`, `제주도 여행`.
3. Pick a **Sort** — relevance or newest first.
4. Set **Max results** (e.g. `500`) and press **Start**.

```json
{
  "mode": "blog",
  "queries": ["강남 맛집", "제주도 여행"],
  "sort": "relevance",
  "maxResults": 500
}
```

#### Option B — Scrape Naver Knowledge-iN (지식iN)

1. Set **Mode** to *Naver Knowledge-iN*.
2. Add your **Search terms**, e.g. `아이폰`, `노트북 추천`.
3. Set **Max results** and press **Start**.

```json
{
  "mode": "kin",
  "queries": ["아이폰", "노트북 추천"],
  "maxResults": 500
}
```

> Leave everything blank and just press **Start** — the actor runs a set of popular default queries and returns 500+ blog posts, so you can see the output shape immediately.

***

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string (select) | `blog` | `blog` = Naver Blog posts, `kin` = Knowledge-iN Q\&A |
| `queries` | array of strings | `["맛집","여행","리뷰","추천"]` | One or more search terms; results are merged & deduped |
| `sort` | string (select) | `relevance` | Blog sort order: `relevance` or `date` (newest first) |
| `maxResults` | integer | `500` | Max unique rows across all queries (1–20,000) |
| `proxy` | object | Apify Proxy AUTO | Proxy configuration; datacenter/AUTO is enough |

Full input example:

```json
{
  "mode": "blog",
  "queries": ["강남 맛집", "성수동 카페", "제주도 여행"],
  "sort": "date",
  "maxResults": 1000,
  "proxy": { "useApifyProxy": true }
}
```

***

### Output example (Naver Knowledge-iN)

```json
{
  "questionId": "493218156",
  "dirId": "1070401",
  "title": "아이폰 초기화 방법 질문",
  "url": "https://kin.naver.com/qna/detail.naver?dirId=1070401&docId=493218156",
  "contentSnippet": "제가 아이폰을 새로 구매하게 되어서 전에 쓰던 아이폰은 세컨폰으로 ...",
  "dateText": "2026.05.02.",
  "date": "2026-05-02",
  "tags": ["아이폰", "핸드폰초기화"],
  "query": "아이폰",
  "_mode": "kin",
  "scrapedAt": "2026-07-25T09:14:02.771Z"
}
```

***

### Tips for best results

- **Use several related queries** in the `queries` list to multiply volume and coverage — each term is paginated independently and merged.
- **Search in Korean** for the richest results; Naver indexes Korean-language content most deeply.
- **Sort by `date`** when you care about freshness (trend tracking, news-like monitoring); use `relevance` for evergreen research.
- **Filter on `isSponsored`** after export to separate organic reviews from paid/marketing posts.
- **Build blogger lists** from `bloggerName` + `blogUrl` + `profileImageUrl` for influencer outreach.
- **Keep `maxResults` realistic per query** — a single keyword tops out around ~1,000 posts on Naver Blog; add more queries to go higher.
- **Schedule it** (e.g. daily) and diff runs to monitor how a topic or product evolves.
- **Datacenter proxy is fine** — only switch to Residential if you notice throttling in the log.
- **Knowledge-iN mode** is ideal for FAQ/voice-of-customer mining; combine it with Blog mode for a full picture of a keyword.

***

### Integrations

Connect Naver Scraper to the rest of your stack with Apify's built-in integrations:

- **Google Sheets** — push results to a sheet automatically after each run.
- **Slack / email** — get notified when a run finishes.
- **Zapier & Make** — trigger 6,000+ downstream apps.
- **Webhooks** — POST new datasets to your own endpoint in real time.
- **Schedule** — run hourly/daily/weekly with Apify Schedules.
- **API & MCP** — pull data programmatically or expose it to AI agents (below).

***

### API usage

Run the actor and fetch results via the Apify API. Replace `<TOKEN>` with your Apify API token.

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~naver-scraper/runs?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode":"blog","queries":["강남 맛집"],"maxResults":500}'
```

**Node.js (apify-client)**

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

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

const run = await client.actor('logiover/naver-scraper').call({
    mode: 'blog',
    queries: ['강남 맛집', '제주도 여행'],
    maxResults: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python (apify-client)**

```python
from apify_client import ApifyClient

client = ApifyClient("<TOKEN>")

run = client.actor("logiover/naver-scraper").call(run_input={
    "mode": "blog",
    "queries": ["강남 맛집", "제주도 여행"],
    "maxResults": 500,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

***

### Use with AI agents (MCP)

Naver Scraper works as a tool for AI agents via the Apify MCP server, so an LLM can fetch live Korean web data on demand. Point your MCP-compatible client (Claude, Cursor, etc.) at Apify's MCP server and let the agent call this actor.

Example agent prompt:

> "Use the Naver scraper to get the 200 most recent Naver Blog posts about '전기차 보조금' and summarise the three most common themes."

***

### Frequently asked questions

#### Is Naver Scraper really keyless?

Yes. It uses Naver's public search endpoints directly — you don't need a Naver Developers application, client ID/secret, login, or cookies.

#### Which Naver surfaces are supported?

Naver Blog search and Naver Knowledge-iN (지식iN) search. Naver Shopping and Naver Place (map) are protected by an anti-bot challenge and are intentionally not included, so you never get a broken run.

#### How many results can I get?

A single blog query returns up to ~1,000 posts; add more queries to go higher (up to 20,000 per run). Knowledge-iN volume depends on how many results the keyword has.

#### Why did I get fewer results than `maxResults`?

Either your keyword simply has fewer indexed results, or the run hit its time budget. Add more `queries` or raise the limit and re-run.

#### Some fields are null — why?

Blog-only fields (blogger, thumbnails, publish date) are null on Knowledge-iN rows and vice-versa, because the two surfaces expose different data. Filter by `_mode`.

#### Can I search in English or other languages?

Yes, but Naver indexes Korean content most deeply, so Korean queries return the richest, largest result sets.

#### How do I export the data?

From the run's Dataset tab, export to CSV, Excel, JSON, XML or HTML, or push to Google Sheets — one click, or via the API.

#### How fast is it?

Because it's pure HTTP (no browser), a 500-result blog run typically finishes in a couple of minutes on 512 MB.

#### Can I get the full blog post body?

This actor returns search-result data (title, snippet, metadata, links). For full post bodies, follow the `url` field with a generic article/HTML scraper.

#### How often is the data updated?

It's live — every run queries Naver in real time. Schedule the actor to keep a fresh dataset.

#### Do I need proxies?

Apify Proxy (AUTO/datacenter) is enabled by default and is enough. Switch to Residential only if you see throttling.

***

### Is it legal?

Naver Scraper collects **publicly available** search-result data that anyone can view in a browser without logging in. It does not access private messages, gated pages, or personal accounts. As with any scraping, you are responsible for how you use the data: respect Naver's Terms of Service, applicable copyright, and privacy laws (e.g. PIPA/GDPR) — especially when handling personal data such as blogger names or profiles. Use the data for research, analytics and lead generation in a lawful, ethical way, and don't republish copyrighted content wholesale.

***

### Related scrapers

Looking for more? Check out these other keyless scrapers by the same developer:

- **RedNote (Xiaohongshu) Scraper** — trending notes & creator discovery across dozens of channels.
- **TikTok Hashtag / Sound Scraper** — pull videos and creator leads by hashtag or sound.
- **X (Twitter) Profile & Tweet Scraper** — profiles, tweets and posts via guest token.
- **Trustpilot Reviews Scraper** — company reviews with ratings and reviewer data.

Have a Naver surface you'd like added? Let us know.

### 📝 Changelog

#### 2026-08-01

- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Replaced the field-level output schema with a canonical `results` dataset link so run results open correctly in the Apify Console.
- Declared 20 dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder.
- Declared 25 nullable dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder or brittle to sparse modes.
- Made all-mode zero-output and dataset-push failures terminate the run explicitly instead of logging an error and reporting SUCCEEDED with an empty dataset.

#### 2026-08-01 — Health-check remediation

- August 2026 monthly health-check remediation is in progress; this build contains fixes verified from empty/default, Console-default, targeted live probes, or field-level semantic review.
- Replaced the field-level output schema with a canonical `results` dataset link so run results open correctly in the Apify Console.
- The final four-input matrix verdict will be appended after post-build cloud revalidation.
- Dataset-push errors and all-mode zero-output conditions now fail explicitly instead of being hidden behind a successful empty run; the inferred contract is nullable across sparse Blog/Knowledge-iN fields.

# Actor input Schema

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

Which Naver surface to scrape. blog = Naver Blog posts (default). kin = Naver Knowledge-iN (지식iN) questions & answers.

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

One or more keywords to search for (Korean or any language). Each term is paginated and results are merged & deduped. Leave empty to use popular default queries.

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

Result ordering for Naver Blog search. relevance = best match (default). date = newest first.

## `maxResults` (type: `integer`):

Maximum number of unique rows to collect across all queries. The scraper paginates and fans out over your search terms until it reaches this number or the time budget.

## `proxy` (type: `object`):

Apify Proxy (AUTO / datacenter) is enough for Naver's keyless endpoints and keeps runs cheap. Switch to Residential only if you see throttling.

## Actor input object example

```json
{
  "mode": "blog",
  "queries": [
    "맛집",
    "여행"
  ],
  "sort": "relevance",
  "maxResults": 500,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All structured records produced by this run. Open the Dataset tab to inspect or export them.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "맛집",
        "여행"
    ],
    "maxResults": 500,
    "proxy": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/naver-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 = {
    "queries": [
        "맛집",
        "여행",
    ],
    "maxResults": 500,
    "proxy": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/naver-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "맛집",
    "여행"
  ],
  "maxResults": 500,
  "proxy": {
    "useApifyProxy": true
  }
}' |
apify call logiover/naver-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=logiover/naver-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oQloBTgTPRYpZKBzc/builds/lvfWgRdvTl0BHSXhV/openapi.json