# Naver Blog Search Scraper (`searchapi/naver-blog-search-scraper`) Actor

Scrapes Naver Blog search results for any keyword. Extracts blog post title, URL, snippet, blogger name, date, thumbnail, and blog name from search.naver.com blog tab.

- **URL**: https://apify.com/searchapi/naver-blog-search-scraper.md
- **Developed by:** [Search API](https://apify.com/searchapi) (community)
- **Categories:** News, SEO tools, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 search results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

### What does Naver Blog Search Scraper do?

Naver Blog Search Scraper is a **Naver Blog search API alternative** that collects public post cards from the current [Naver Blog search](https://search.naver.com/). Enter one Korean or international keyword, or submit a small batch of queries, and the Actor returns structured posts with stable blog/post identifiers, ranking, title, snippet, blog attribution, publication label, thumbnail, and provenance. It does not open private posts, bypass login, or extract hidden account data.

### Why scrape Naver Blog search?

- Monitor Korean consumer conversations and creator coverage.
- Research brand, product, destination, and technology mentions.
- Build public-content discovery, SEO, and trend-monitoring workflows.
- Schedule recurring runs and export results through Apify datasets, webhooks, integrations, or API calls.

The Actor uses Naver's current Blog-tab route, stops on repeated pages, enforces item and page limits, deduplicates stable post IDs, and detects access challenges instead of storing them as results.

### What data can it extract?

| Field | Type | Description |
| --- | --- | --- |
| `id` | string | Stable query-ranking ID; `postKey` remains stable across queries |
| `postId`, `blogId` | string | Public identifiers from the canonical post URL |
| `title`, `snippet` | string | Public search-card title and summary |
| `url`, `blogUrl` | string | Canonical post and blog URLs |
| `blogName` | string | Public blog display name when shown |
| `authorName` | string | Public author or creator display name shown by Naver |
| `authorUrl` | string | Public author profile URL shown by Naver |
| `dateRaw`, `publishedAt` | string | Source label and normalized Korean date when parseable |
| `thumbnailUrl` | string | Search-card thumbnail when available |
| `queryPosition`, `page` | integer | Query-relative rank and result page |
| `query`, `searchUrl`, `scrapedAt` | string | Search and scrape provenance |

Unavailable optional values are omitted rather than replaced with `N/A`, zeroes, or fabricated placeholders.

### How to scrape Naver Blog

1. Open the Actor input tab.
2. Enter `query`, or provide several values in `queries`.
3. Set `maxItems` and `maxPages` to bound the run.
4. Leave concurrency low for reliable Naver access.
5. Enable an authorized Apify Proxy only when direct access is blocked.
6. Run the Actor and inspect the dataset Output tab.

```json
{
  "query": "인공지능",
  "maxItems": 10,
  "maxPages": 2,
  "maxConcurrency": 1,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### Output

The default dataset contains one item per query-specific post ranking. You can download it as JSON, CSV, Excel, HTML, XML, or RSS, or access it through the Apify API.

```json
{
  "id": "naver-blog:example:12345:q:%EC%9D%B8%EA%B3%B5%EC%A7%80%EB%8A%A5",
  "postKey": "example:12345",
  "postId": "12345",
  "blogId": "example",
  "queryPosition": 1,
  "page": 1,
  "title": "Public Naver Blog post title",
  "url": "https://blog.naver.com/example/12345",
  "blogName": "Example blog",
  "authorName": "Example author",
  "authorUrl": "https://in.naver.com/example",
  "query": "인공지능",
  "sourceDomain": "search.naver.com"
}
```

### Cost and performance tips

Cost depends on browser runtime, selected memory, and proxy traffic. Start with 5–10 items and one page. Increase limits only after verifying the query. The Actor blocks media/font downloads, uses bounded retries, and stops pagination when pages repeat or the requested quota is reached.

### Legal, privacy, and support

Use the Actor only for public information and comply with Naver's terms, robots directives, and applicable privacy law. Public posts can still contain personal data; process it only with a legitimate basis. Challenge or CAPTCHA pages are never saved as records. For help, use the Actor's Issues tab; for programmatic runs, use its API tab.

# Actor input Schema

## `query` (type: `string`):

The search term to look up on Naver Blog

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

Optional batch of search queries. Duplicate and blank values are removed.

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

Maximum number of blog results to scrape

## `maxPages` (type: `integer`):

Hard pagination limit for each query.

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

Maximum number of Naver result pages processed at once.

## `maxRequestRetries` (type: `integer`):

Retries transient navigation, rate-limit, or proxy failures.

## `proxyConfiguration` (type: `object`):

Proxy settings for the scraper

## Actor input object example

```json
{
  "query": "맛집",
  "queries": [],
  "maxItems": 50,
  "maxPages": 3,
  "maxConcurrency": 2,
  "maxRequestRetries": 2
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "query": "인공지능"
};

// Run the Actor and wait for it to finish
const run = await client.actor("searchapi/naver-blog-search-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 = { "query": "인공지능" }

# Run the Actor and wait for it to finish
run = client.actor("searchapi/naver-blog-search-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 '{
  "query": "인공지능"
}' |
apify call searchapi/naver-blog-search-scraper --silent --output-dataset

```

## MCP server setup

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