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

🔎 Search public Naver Blog by keyword or URL. Export clean full post text, authors, dates, images, hashtags, comments, ranking context, and canonical IDs for Korean SEO and brand research.

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

## Pricing

Pay per event

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Blog Search Scraper

Search public **Naver Blog (네이버 블로그)** posts by keyword and turn them into structured data.

This Actor combines Naver Blog search discovery with full article extraction in one run. It returns clean post text, authors, publication dates, images, hashtags, comments, canonical IDs, and search ranking context.

Use it for Korean SEO research, brand monitoring, travel and consumer research, content analysis, or recurring market-intelligence pipelines.

### What does Naver Blog Search Scraper do?

Naver Blog Search Scraper accepts Korean or international-language keywords and public Naver Blog post URLs.

For keyword searches, it:

- 🔎 searches Naver's public Blog collection;
- 📊 preserves the keyword and result rank;
- 🔗 deduplicates posts by canonical URL;
- 📄 visits each public post for full content;
- 🖼️ extracts article images and thumbnails;
- 🏷️ captures hashtags when the author published them;
- 📅 normalizes publication dates;
- 💬 captures public comment and like counts when exposed;
- 💾 writes one structured post per dataset row.

You can also disable full-content extraction for a faster discovery-only workflow.

### Why use this Naver Blog scraper?

Naver Blog is central to Korean search behavior, recommendations, travel planning, reviews, and product discovery.

Raw Naver pages are designed for readers rather than data workflows. Posts may use Naver SmartEditor markup, mobile URLs, and source-specific metadata.

This Actor normalizes those differences into one stable record shape.

Key benefits:

- no Naver developer API credentials required;
- no account or login required for public posts;
- keyword search and direct URL extraction in one Actor;
- Korean text preserved as Unicode;
- clear `complete`, `partial`, or `search-only` status;
- global deduplication across keywords and direct URLs;
- configurable date filters and sorting;
- optional Apify Proxy support;
- exports to JSON, CSV, Excel, XML, RSS, and integrations.

### Who is it for?

#### SEO and content teams

Discover which Naver Blog articles rank for target Korean keywords, inspect titles and full copy, and compare recurring topics.

#### Brand and communications teams

Monitor public posts that mention products, campaigns, competitors, or executives. Schedule the Actor and send new records to a webhook or database.

#### Travel and hospitality researchers

Collect public destination, restaurant, hotel, and itinerary posts while retaining dates, images, authors, and source links.

#### Market researchers

Build structured corpora for Korean-language topic analysis, qualitative coding, trend review, and competitive intelligence.

#### Data and AI teams

Feed normalized Korean article text to classification, summarization, embedding, retrieval, or LLM workflows.

### What data can you extract?

| Field | Description |
|---|---|
| `query` | Keyword that discovered the post |
| `rank` | Rank within that keyword's search results |
| `url` | Canonical public Naver Blog post URL |
| `blogId` | Naver Blog identifier |
| `logNo` | Naver post identifier |
| `title` | Public post title |
| `authorName` | Public author nickname |
| `publishedAt` | Normalized ISO 8601 publication timestamp |
| `publishedAtRaw` | Publication date exactly as shown by Naver |
| `summary` | Search or Open Graph description |
| `contentText` | Clean full article text |
| `contentHtml` | Article-container HTML for structure-aware use |
| `imageUrls` | Deduplicated full-size article image URLs |
| `hashtags` | Author-published hashtags |
| `thumbnailUrl` | Search or Open Graph thumbnail |
| `commentCount` | Public comment count when exposed |
| `likeCount` | Public like count when exposed |
| `extractionStatus` | `complete`, `partial`, or `search-only` |
| `error` | Detail-page error when a useful search record is retained |
| `scrapedAt` | Extraction timestamp |

Optional source fields are omitted when Naver does not expose them. The Actor does not invent private analytics or engagement values.

### How to scrape Naver Blog search results

1. Open the Actor input page.
2. Add one or more values to **Search keywords**.
3. Keep **Extract full post content** enabled for complete records.
4. Set a low **Maximum blog posts** value for your first run.
5. Optionally choose newest-first sorting or a publication date range.
6. Click **Start**.
7. Open the default dataset to preview or export records.

A useful first input is:

```json
{
  "queries": ["제주도 여행"],
  "maxItems": 10,
  "includeContent": true
}
````

### How to extract specific Naver Blog posts

Provide public post URLs in `startUrls`.

Accepted forms include desktop, mobile, and `PostView` URLs that contain a valid `blogId` and numeric `logNo`.

```json
{
  "queries": [],
  "startUrls": [
    { "url": "https://blog.naver.com/daniuni/223602726394" }
  ],
  "maxItems": 1,
  "includeContent": true
}
```

URLs outside public Naver Blog post scope fail closed instead of producing misleading output.

### Input options

| Input | Type | Default | Purpose |
|---|---|---:|---|
| `queries` | string array | `제주도 여행` | Naver Blog search keywords |
| `startUrls` | URL array | empty | Direct public Naver Blog posts |
| `maxItems` | integer | `20` | Global unique post limit |
| `sort` | string | `relevance` | `relevance` or `newest` |
| `fromDate` | string | empty | Inclusive `YYYY-MM-DD` lower bound |
| `toDate` | string | empty | Inclusive `YYYY-MM-DD` upper bound |
| `includeContent` | boolean | `true` | Fetch full public post pages |
| `maxConcurrency` | integer | `5` | Concurrent detail requests, capped at 10 |
| `proxyConfiguration` | object | direct | Optional Apify Proxy settings |

At least one keyword or direct post URL is required.

If both date fields are supplied, `fromDate` must not be later than `toDate`.

### Search sorting and date filters

Use `sort: "relevance"` to preserve Naver's relevance ranking.

Use `sort: "newest"` for monitoring and incremental research.

Date filters are inclusive and use Korea-oriented Naver search semantics.

Example:

```json
{
  "queries": ["서울 카페"],
  "sort": "newest",
  "fromDate": "2026-07-01",
  "toDate": "2026-07-18",
  "maxItems": 30
}
```

Invalid dates are rejected before requests are made.

### Example output

```json
{
  "query": "제주도 여행",
  "rank": 1,
  "url": "https://blog.naver.com/hewtbylvv/224340192335",
  "blogId": "hewtbylvv",
  "logNo": "224340192335",
  "title": "제주도 여행 지도 필수 코스 관광지 추천",
  "authorName": "비야",
  "publishedAt": "2026-07-08T12:05:00+09:00",
  "summary": "오늘은 제주특별자치도에서 제작한...",
  "contentText": "오늘은 제주특별자치도에서 제작한 제주도 지도를...",
  "imageUrls": ["https://postfiles.pstatic.net/example.jpg"],
  "hashtags": ["제주도여행", "제주여행코스"],
  "commentCount": 4,
  "extractionStatus": "complete",
  "scrapedAt": "2026-07-18T05:50:00.000Z"
}
```

Values vary by public post. Fields that are not exposed are omitted.

### Extraction status and partial records

`complete` means full public post text was extracted.

`partial` means useful detail metadata was available but the main article text was not.

`search-only` means either:

- `includeContent` was disabled; or
- search metadata was useful but a detail request temporarily failed.

When a detail failure occurs, the `error` field explains what happened. This lets monitoring workflows keep useful discoveries without confusing them with complete articles.

A run that cannot produce any useful post record fails rather than silently succeeding with an empty dataset.

### How much does it cost to scrape Naver Blog posts?

The Actor uses pay-per-event pricing:

- a **$0.005** start event per run;
- one item event for each useful post record saved.

| Apify plan tier | Price per saved post |
|---|---:|
| FREE | $0.00013796 |
| BRONZE | $0.00011996 |
| SILVER | $0.00009357 |
| GOLD | $0.000071977 |
| PLATINUM | $0.000047985 |
| DIAMOND | $0.000033589 |

For example, 100 saved posts on BRONZE cost about **$0.017**: $0.005 start + $0.011996 in post events. Platform usage may be billed according to your Apify plan.

Keep first runs small. A 10-post sample is usually enough to validate a keyword before scheduling larger extraction.

You are never charged an item event for a failed direct URL that produces no useful record.

### Tips for better Naver Blog results

- 🇰🇷 Use Korean search phrases when researching Korean audiences.
- 🎯 Prefer specific phrases such as `성수동 카페 신상` over a single broad noun.
- 📅 Use newest-first with a date range for recurring monitoring.
- 🧪 Start with 5–10 posts before increasing `maxItems`.
- 🔗 Add direct URLs when you already know the exact articles you need.
- 📝 Keep full-content extraction enabled for NLP or qualitative research.
- ⚡ Disable full content when you only need rankings, titles, and URLs.
- 🌐 Enable a proxy only if your environment is rate-limited.
- 🧹 Deduplicate downstream by `url`, `blogId`, and `logNo`.

### Scheduling a Naver Blog monitor

Apify schedules can run the Actor hourly, daily, or weekly.

A typical brand-monitoring workflow is:

1. set focused brand and product keywords;
2. select newest-first sorting;
3. use a recent date window;
4. run on a daily schedule;
5. send the dataset to a webhook;
6. deduplicate against previously stored canonical URLs;
7. alert only on newly discovered posts.

For rolling date windows, generate the input in your orchestrator or use an Apify automation that updates the date fields.

### Integrations

#### Google Sheets and Airtable

Export dataset rows to a review sheet for content, PR, or research teams.

#### Webhooks and automation platforms

Trigger Make, Zapier, n8n, or your own endpoint when a run finishes.

#### Data warehouses

Load JSON or CSV records into BigQuery, Snowflake, PostgreSQL, or object storage.

#### AI and NLP pipelines

Use `contentText` for summarization, sentiment review, topic classification, embeddings, or retrieval-augmented generation.

#### Slack or email alerts

Filter newest records and send title, author, summary, and source URL to a monitoring channel.

### Use with the Apify API

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/naver-blog-search-scraper').call({
  queries: ['제주도 여행'],
  maxItems: 20,
  includeContent: true,
});

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

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/naver-blog-search-scraper').call(run_input={
    'queries': ['제주도 여행'],
    'maxItems': 20,
    'includeContent': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~naver-blog-search-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["제주도 여행"],"maxItems":20,"includeContent":true}'
```

Never commit your Apify token to source control.

### Use with Apify MCP

Connect the Actor through:

`https://mcp.apify.com/?tools=automation-lab/naver-blog-search-scraper`

#### Claude Code setup

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

#### Claude Desktop setup

Add this to your Claude Desktop MCP configuration:

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

#### Cursor setup

Add the same `mcpServers` JSON to Cursor's MCP configuration and authenticate with your Apify account when prompted.

#### VS Code setup

Open the MCP server configuration in VS Code, add the Apify HTTP server URL above, and complete Apify authentication.

Example prompts:

- “Run the Naver Blog scraper for `제주도 여행` and summarize the themes in the first 20 posts.”
- “Extract this Naver Blog URL and return the author, publish date, hashtags, and image links.”
- “Find newest public Naver Blog mentions of these Korean product names and group them by keyword.”

### Performance and reliability

The Actor uses direct server-rendered HTTP rather than a browser runtime.

That keeps startup time, memory, and compute use low.

Reliability controls include:

- bounded detail concurrency;
- browser-like request headers;
- request timeouts;
- retry backoff;
- canonical URL normalization;
- global deduplication;
- optional proxy rotation;
- explicit zero-output failure;
- transparent partial status.

Naver may change public HTML layouts. If extraction quality changes, include the affected keyword or post URL when reporting the issue.

### Troubleshooting

#### Why did I receive `search-only` records?

Check whether `includeContent` is false. If it is true, inspect the optional `error` field. A temporary detail-page block can retain useful search metadata while disclosing that full content was unavailable.

#### Why are some engagement fields missing?

Naver does not expose the same public engagement elements on every post or layout. Missing fields are omitted instead of set to invented zero values.

#### Why did my URL fail validation?

The URL must identify a public Naver Blog post and contain both a blog ID and numeric post ID. Profile pages, category pages, and unrelated websites are intentionally rejected.

#### Why are newest results less relevant?

Newest-first ordering prioritizes publication recency over semantic relevance. Use relevance sorting for content discovery and newest sorting for monitoring.

#### How can I reduce rate limiting?

Lower `maxConcurrency`, reduce `maxItems`, or configure Apify Proxy. Avoid repeatedly scraping large overlapping date ranges.

### Data quality notes

Naver's displayed search rank is query- and time-dependent.

The same post may rank for several keywords. This Actor emits it once per run and keeps the provenance from its first discovery.

Publication timestamps use the public value shown by Naver and are normalized with Korea's `+09:00` offset when the source format can be parsed.

Article text is extracted from Naver SmartEditor content. Complex embeds, maps, videos, and interactive widgets may be represented by surrounding text or links rather than rendered media.

### Is scraping Naver Blog legal?

This Actor extracts data from publicly accessible pages. It does not bypass logins or collect private posts.

Scraping legality depends on your jurisdiction, purpose, volume, contractual obligations, and the type of personal data involved.

You are responsible for:

- complying with applicable laws and Naver's terms;
- using a proportionate request rate;
- respecting copyright and attribution requirements;
- establishing a lawful basis for personal-data processing;
- honoring deletion or access requests where required;
- avoiding harassment, spam, or harmful profiling.

Public availability does not automatically grant rights to republish an author's full work. Consult qualified counsel for your use case.

### Related scrapers

Build a broader Korean market-data workflow with other automation-lab Actors:

- [Naver Map Local Business Scraper](https://apify.com/automation-lab/naver-map-local-business-scraper) for Korean place and business discovery.
- [Naver Shopping Product Scraper](https://apify.com/automation-lab/naver-shopping-product-scraper) for product and merchant research.
- [Google Search Results Scraper](https://apify.com/automation-lab/google-search-scraper) for cross-engine ranking comparisons.

Each Actor has its own input and output contract. Combine datasets by canonical URLs or business identifiers rather than assuming records are identical.

### FAQ

#### Does it require a Naver account?

No. The Actor targets anonymously visible public search results and public posts.

#### Does it require Naver Open API credentials?

No. It uses public server-rendered web surfaces.

#### Can it scrape mobile Naver Blog URLs?

Yes. Supported mobile post URLs are normalized to canonical desktop URLs.

#### Can it search multiple keywords?

Yes. Add multiple strings to `queries`. The global `maxItems` cap applies across the entire run.

#### Does it extract full HTML?

It returns both clean `contentText` and the article container's `contentHtml` when available.

#### Can it extract comments themselves?

This version captures the public comment count when exposed, not individual comment threads.

#### Can it scrape private posts?

No. Private, login-only, deleted, or otherwise unavailable posts are outside the product scope.

#### Can I export to CSV or Excel?

Yes. Open the dataset and choose CSV, Excel, JSON, XML, or another supported format.

#### Can I run it on a schedule?

Yes. Use Apify schedules and webhooks for recurring monitoring.

#### How are duplicates handled?

Posts are deduplicated globally by canonical Naver Blog URL before detail requests and output.

### Support

If a public post or keyword no longer extracts correctly, share:

- the Actor run URL;
- the keyword or public Naver Blog URL;
- the expected field;
- the observed extraction status;
- whether a proxy was enabled.

Do not share private credentials, cookies, or personal account data.

# Actor input Schema

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

Keywords to search in Naver Blog, for example 제주도 여행 or 강남 카페.

## `startUrls` (type: `array`):

Optional public post URLs such as https://blog.naver.com/blogId/123456789. Other websites are rejected.

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

Global maximum number of unique post records across all keywords and URLs.

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

Use Naver relevance ranking or newest posts first.

## `fromDate` (type: `string`):

Optional inclusive start date in YYYY-MM-DD format.

## `toDate` (type: `string`):

Optional inclusive end date in YYYY-MM-DD format.

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

Fetch every public post page for full text, images, author, date, and engagement metadata. Disable for faster discovery-only results.

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

Lower this if Naver rate-limits your traffic. The Actor always caps concurrency at 10.

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

Use Apify Proxy when your network or Naver rate limits require IP rotation. Direct anonymous HTTP is used by default.

## Actor input object example

```json
{
  "queries": [
    "제주도 여행"
  ],
  "startUrls": [],
  "maxItems": 10,
  "sort": "relevance",
  "includeContent": true,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "제주도 여행"
    ],
    "startUrls": [],
    "maxItems": 10,
    "sort": "relevance",
    "includeContent": true,
    "maxConcurrency": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "queries": ["제주도 여행"],
    "startUrls": [],
    "maxItems": 10,
    "sort": "relevance",
    "includeContent": True,
    "maxConcurrency": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/naver-blog-search-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": [
    "제주도 여행"
  ],
  "startUrls": [],
  "maxItems": 10,
  "sort": "relevance",
  "includeContent": true,
  "maxConcurrency": 3
}' |
apify call automation-lab/naver-blog-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver Blog Search Scraper",
        "description": "🔎 Search public Naver Blog by keyword or URL. Export clean full post text, authors, dates, images, hashtags, comments, ranking context, and canonical IDs for Korean SEO and brand research.",
        "version": "0.1",
        "x-build-id": "3MCAtk1a9X5qAcUJO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~naver-blog-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-naver-blog-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~naver-blog-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-naver-blog-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~naver-blog-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-naver-blog-search-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "queries": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Keywords to search in Naver Blog, for example 제주도 여행 or 강남 카페.",
                        "default": [
                            "제주도 여행"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Direct Naver Blog post URLs",
                        "type": "array",
                        "description": "Optional public post URLs such as https://blog.naver.com/blogId/123456789. Other websites are rejected.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum blog posts",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Global maximum number of unique post records across all keywords and URLs.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Use Naver relevance ranking or newest posts first.",
                        "default": "relevance"
                    },
                    "fromDate": {
                        "title": "Published on or after",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive start date in YYYY-MM-DD format."
                    },
                    "toDate": {
                        "title": "Published on or before",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive end date in YYYY-MM-DD format."
                    },
                    "includeContent": {
                        "title": "Extract full post content",
                        "type": "boolean",
                        "description": "Fetch every public post page for full text, images, author, date, and engagement metadata. Disable for faster discovery-only results.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrent post requests",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Lower this if Naver rate-limits your traffic. The Actor always caps concurrency at 10.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy when your network or Naver rate limits require IP rotation. Direct anonymous HTTP is used by default.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```