# Naver Maps Reviews Scraper (`hgservices/naver-maps-reviews-scraper`) Actor

Extract all reviews of a place from Naver Maps. Scrape visitor reviews (방문자 리뷰) and blog/café reviews (블로그·카페 리뷰) from any Naver Maps place — full review text, rating, visit keywords, dates, photos, owner replies and reviewer info. One row per review.

- **URL**: https://apify.com/hgservices/naver-maps-reviews-scraper.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Categories:** E-commerce, Travel, AI
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 review scrapeds

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 Maps Reviews Scraper

**Scrape reviews from any place on [Naver Maps](https://map.naver.com)** — Korea's dominant maps and local-search service — without an API key or a headless browser. Give the Actor a place (by URL, ID, or search term) and get back every review as clean, structured data: **full review text, rating, visit keywords, dates, photos, owner replies and reviewer info** — one row per review, ready to export to JSON, CSV or Excel.

Naver Maps is where Korean consumers actually rate and review restaurants, cafés, clinics and shops — the reviews that shape local reputation in South Korea, and that you **can't get from Google Maps**, which has thin coverage there. If you're doing reputation monitoring, competitor research, sentiment analysis or voice-of-customer work for the Korean market, this is the source.

### What does Naver Maps Reviews Scraper do?

It collects **both kinds of review Naver shows** for a place:

- **Visitor reviews (방문자 리뷰)** — reviews written directly on the place page by people who visited, including a rating, the review text, **visit keywords** (e.g. "food was delicious", "good for groups"), visit date, visit count, verification type (e.g. receipt-verified), photos, and any **owner reply**.
- **Blog & café reviews (블로그·카페 리뷰)** — external **Naver Blog** and **Naver Café** posts about the place, with the post title, an excerpt, the author, the date and a link to the full post.

You can scrape one, the other, or both. Every review is stamped with its **place context** (name, category, address, coordinates, place URL), so a single export is ready for analysis with no joining required.

Because it runs on the Apify platform, you also get scheduling, a REST API, webhooks, and integrations with Make, Zapier and n8n — plus automatic Korean proxy rotation so runs stay reliable.

### Why use Naver Maps Reviews Scraper?

- **Monitor your reputation** — pull every review for your locations and track ratings, keywords and complaints over time.
- **Research competitors** — see what customers praise and criticise at rival places, at scale.
- **Analyse sentiment & keywords** — the visit keywords and full review text are ideal inputs for NLP, topic modelling and CSAT work — in Korean.
- **Feed AI & dashboards** — export structured reviews into your data warehouse, BI tool or LLM pipeline.

### How to use Naver Maps Reviews Scraper

1. **Pick your places.** Paste one or more **Naver place URLs** (e.g. `https://map.naver.com/p/entry/place/1005495070`) or **place IDs** into the input. Or, instead, enter a **search term** (e.g. `강남 삼겹살`) — optionally with a location — to scrape reviews from every matching place.
2. **Choose review options** — how many reviews per place, which review types (visitor / blog / both), and whether to include reviewer personal data.
3. **Click Start** and watch results stream into the dataset.
4. **Export** the data as JSON, CSV, Excel or HTML, or pull it via the Apify API.

#### Finding a place URL

Search for the place on [map.naver.com](https://map.naver.com), open it, and copy the URL from your browser — the number in it (e.g. `1005495070`) is the place ID. `naver.me` share links work too; they're resolved automatically.

### Input

Configure the run from the Apify UI, or via the API. Main options:

- **🔗 Naver place URLs / 🆔 Naver place IDs** — the places to scrape reviews from. The most direct way to target exact places.
- **🔍 Search term(s)** — instead of listing places, discover them by search (e.g. `역삼동 카페`). Reviews are scraped from every matching place. Korean terms match best.
- **📍 Location / 📐 Structured location / 🛰 Custom search area** — optional, to restrict a search to an area (a free-text place like `Gangnam, Seoul`, Korea's administrative hierarchy 시·도 → 시·군·구 → 읍·면·동, or an exact bounding box).
- **⭐ Max reviews per place** — how many reviews to pull from each place (newest first). Set it high to capture a place's whole review history.
- **Review type** — **Both**, **Visitor reviews only**, or **Blog & café reviews only**.
- **Include reviewer personal data** — include the reviewer's nickname, profile link and photo (and blog author name for blog reviews). Turn it off to omit reviewer identity.
- **🌍 Language** — preferred language for content where Naver provides it: Korean, English, Japanese or Chinese.

> When you provide any place URL or ID, the search fields are ignored — direct input takes priority.

> Proxy is handled automatically — every run goes through Apify Residential proxy in **South Korea**, since Naver is geo-sensitive and rate-limits foreign/datacenter IPs. There's nothing to configure.

#### Example input

Scrape the 200 newest visitor and blog reviews for two places:

```json
{
    "placeUrls": ["https://map.naver.com/p/entry/place/1005495070", "https://map.naver.com/p/entry/place/1102875830"],
    "maxReviewsPerPlace": 200,
    "reviewSources": "both"
}
````

Or find places by search and scrape their reviews:

```json
{
    "searchStrings": ["강남 삼겹살"],
    "locationQuery": "Gangnam, Seoul",
    "maxPlacesPerSearch": 10,
    "maxReviewsPerPlace": 50,
    "reviewSources": "visitor"
}
```

### Output

Results are stored as a dataset — **one item per review** — which you can download as JSON, CSV, Excel or HTML, or query via the API. The Actor ships **Reviews**, **Visitor reviews** and **Blog & café reviews** views in the output tab so you can look at each stream on its own.

A **visitor review** looks like:

```json
{
    "placeId": "1005495070",
    "placeName": "영동그집",
    "placeUrl": "https://map.naver.com/p/entry/place/1005495070",
    "category": "육류,고기요리",
    "roadAddress": "서울 강남구 봉은사로1길 42-8",
    "location": { "lat": 37.507466, "lng": 127.024445 },
    "placeReviewTotal": 4718,
    "reviewSource": "visitor",
    "reviewId": "6a5ca80b36db33d084836976",
    "rating": 5,
    "text": "고기도 직접 맛있게 구워주시고 무엇보다 너무 맛있습니다!",
    "visitedDate": "7.18.토",
    "createdDate": "7.19.일",
    "visitCount": 1,
    "originType": "영수증",
    "keywords": ["음식이 맛있어요", "친절해요"],
    "photos": ["https://pup-review-phinf.pstatic.net/…"],
    "reactionCount": 0,
    "ownerReply": null,
    "reviewerName": "또오아",
    "reviewerProfileUrl": "https://m.place.naver.com/my/…/review",
    "scrapedAt": "2026-07-19T11:03:54.876Z"
}
```

A **blog & café review** uses the same fields, with the blog-specific ones filled in (`blogTitle`, `blogUrl`, `blogName`) and review-only fields such as `rating` and `keywords` left empty.

#### Data fields

| Field                                                    | Description                                                 |
| -------------------------------------------------------- | ----------------------------------------------------------- |
| `placeId`, `placeName`, `placeUrl`                       | The place the review belongs to                             |
| `category`, `address`, `roadAddress`, `location`         | Place category and location                                 |
| `placeReviewTotal`                                       | Total visitor reviews the place has                         |
| `reviewSource`                                           | `visitor` or `blog`                                         |
| `reviewId`                                               | Unique review identifier                                    |
| `rating`                                                 | Star rating (often empty — see note below)                  |
| `text`                                                   | Full review text / blog excerpt                             |
| `keywords`                                               | Visit keywords chosen by the reviewer (visitor reviews)     |
| `visitedDate`, `createdDate`                             | When they visited / when the review was written             |
| `visitCount`                                             | How many times the reviewer has visited                     |
| `originType`                                             | How the visit was verified (e.g. receipt) / `blog` / `cafe` |
| `photos`                                                 | Review photo URLs                                           |
| `reactionCount`                                          | "Helpful" reactions on the review                           |
| `ownerReply`                                             | The business owner's reply, if any                          |
| `blogTitle`, `blogUrl`, `blogName`                       | Post title, link and blog (blog reviews)                    |
| `reviewerName`, `reviewerProfileUrl`, `reviewerImageUrl` | Reviewer identity (omitted if personal data is off)         |

### How much does it cost to scrape Naver reviews?

This Actor uses **pay-per-result** pricing — you're billed per review scraped, so cost scales with exactly how much data you pull. A place with 500 reviews costs the same whether you find it by URL or by search. Apify's **free plan** includes monthly usage credits you can use to try it out. See the **Pricing** tab on the Actor's page for the current per-review price, and use **Max reviews per place** to cap spend.

### Tips

- **Get a place's full history:** set **Max reviews per place** high and leave review type on **Both**.
- **Recent reviews only:** reviews come **newest-first**, so a small **Max reviews per place** gives you just the latest ones.
- **Korean search terms** match Naver's index best (e.g. `카페` rather than "cafe").
- **Sentiment work:** the `keywords` and `text` fields together are a strong signal for Korean-language NLP.

### FAQ

**Do I need a Naver API key or account?**
No. The Actor reads publicly available review data from Naver Maps directly — no key, login or credentials required.

**Why are many `rating` values empty?**
Naver has largely moved visitor reviews away from star ratings toward **visit keywords** (e.g. "food was delicious"). So many visitor reviews have no numeric rating — the sentiment lives in the `keywords` and `text` fields instead. Blog & café reviews never carry a rating.

**What's the difference between visitor reviews and blog reviews?**
Visitor reviews (방문자 리뷰) are short reviews written on the place page by visitors. Blog & café reviews (블로그·카페 리뷰) are longer external posts on Naver Blog / Café that mention the place. Both are shown on every Naver place page; this Actor can scrape either or both.

**Why does it use a Korean proxy?**
Naver serves and rate-limits by geography. Requests from South Korean residential IPs are far more reliable, so the Actor routes every run through Apify's Residential proxy in KR. This is handled internally — there's nothing to configure.

**Can I run it on a schedule or from my own app?**
Yes. Like any Apify Actor it can be scheduled and called via the Apify API, the JavaScript / Python clients, or integrations such as Make, Zapier and n8n — see the API tab on the Actor's page.

**Is web scraping legal?**
This Actor collects publicly available information. As with any scraping, you're responsible for how you use the data — in particular, complying with Naver's terms and applicable laws, including data-protection rules such as GDPR when personal data is involved. Use the **Include reviewer personal data** switch to omit reviewer identity when you don't need it. If in doubt, seek legal advice.

### Feedback & support

Found a bug or need another field? Open an issue on the Actor's **Issues** tab — feedback is welcome, and custom tweaks are possible.

# Actor input Schema

## `placeUrls` (type: `array`):

The places whose reviews you want. Paste Naver Maps place URLs — e.g. https://map.naver.com/p/entry/place/1005495070 — or naver.me share links (resolved automatically). This is the simplest way to target exact places.

## `placeIds` (type: `array`):

Raw numeric Naver place IDs (e.g. 1005495070) — the number at the end of a place URL. Combined with any URLs above.

## `searchStrings` (type: `array`):

Instead of listing places, find them by search: enter what you'd type into the Naver Maps search bar, e.g. 삼겹살 (pork BBQ), 강남 카페 (Gangnam cafe). Reviews are then scraped from every matching place. Korean terms match best. One term per line.

## `locationQuery` (type: `string`):

Optional area to restrict the search to, e.g. "Gangnam, Seoul" or "강남구". Resolved to a map area via OpenStreetMap. Leave empty to search all of Naver Maps for the term.

## `province` (type: `string`):

Korea's top administrative tier (시/도) — a special/metropolitan city or a province. e.g. "Seoul" (서울특별시), "Busan" (부산광역시).

## `municipality` (type: `string`):

Korea's municipal tier (시/군/구) — a district (구), city (시) or county (군). e.g. "Gangnam-gu" (강남구), "Suwon-si" (수원시).

## `neighborhood` (type: `string`):

Korea's sub-municipal tier (읍/면/동) — a neighborhood (동), town (읍) or township (면). e.g. "Yeoksam-dong" (역삼동).

## `postalCode` (type: `string`):

5-digit Korean postal code (우편번호). e.g. "06236".

## `customBounds` (type: `array`):

Exact bounding box as \[minLng, minLat, maxLng, maxLat]. Highest priority for search — overrides 📍 Location and the structured fields. Coordinate order is longitude first.

## `maxPlacesPerSearch` (type: `integer`):

When discovering places by search, the maximum number of places to collect per term (reviews are then scraped from each). Ignored in URL / ID mode.

## `maxReviewsPerPlace` (type: `integer`):

The maximum number of reviews to scrape from each place. Reviews come newest-first. Set high to pull a place's entire review history. Split across the enabled review sources below.

## `reviewSources` (type: `string`):

Which Naver reviews to scrape. Naver has two kinds: Visitor reviews (방문자 리뷰) written on the place page, and Blog & café reviews (블로그·카페 리뷰) — external Naver Blog/Café posts linked to the place.

## `includePersonalData` (type: `boolean`):

Include the reviewer's identity — nickname, profile URL and photo (and the blog author's name / blog for blog reviews). Personal data may be protected by law (e.g. GDPR); turn this off to omit reviewer identity from the output.

## `language` (type: `string`):

Preferred response language for review content and place info, where Naver provides it.

## Actor input object example

```json
{
  "placeUrls": [
    "https://map.naver.com/p/entry/place/1005495070"
  ],
  "placeIds": [
    "1005495070"
  ],
  "searchStrings": [
    "강남 삼겹살"
  ],
  "locationQuery": "Gangnam, Seoul",
  "province": "Seoul",
  "municipality": "Gangnam-gu",
  "customBounds": [
    127.02,
    37.49,
    127.07,
    37.52
  ],
  "maxPlacesPerSearch": 20,
  "maxReviewsPerPlace": 100,
  "reviewSources": "both",
  "includePersonalData": true,
  "language": "ko"
}
```

# 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 = {
    "placeUrls": [
        "https://map.naver.com/p/entry/place/1005495070"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/naver-maps-reviews-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 = { "placeUrls": ["https://map.naver.com/p/entry/place/1005495070"] }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/naver-maps-reviews-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 '{
  "placeUrls": [
    "https://map.naver.com/p/entry/place/1005495070"
  ]
}' |
apify call hgservices/naver-maps-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver Maps Reviews Scraper",
        "description": "Extract all reviews of a place from Naver Maps. Scrape visitor reviews (방문자 리뷰) and blog/café reviews (블로그·카페 리뷰) from any Naver Maps place — full review text, rating, visit keywords, dates, photos, owner replies and reviewer info. One row per review.",
        "version": "0.1",
        "x-build-id": "NpGuPIJ2Zbj3gezq2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hgservices~naver-maps-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hgservices-naver-maps-reviews-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/hgservices~naver-maps-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-hgservices-naver-maps-reviews-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/hgservices~naver-maps-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-hgservices-naver-maps-reviews-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": {
                    "placeUrls": {
                        "title": "🔗 Naver place URLs",
                        "type": "array",
                        "description": "The places whose reviews you want. Paste Naver Maps place URLs — e.g. https://map.naver.com/p/entry/place/1005495070 — or naver.me share links (resolved automatically). This is the simplest way to target exact places.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeIds": {
                        "title": "🆔 Naver place IDs",
                        "type": "array",
                        "description": "Raw numeric Naver place IDs (e.g. 1005495070) — the number at the end of a place URL. Combined with any URLs above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchStrings": {
                        "title": "🔍 Search term(s)",
                        "type": "array",
                        "description": "Instead of listing places, find them by search: enter what you'd type into the Naver Maps search bar, e.g. 삼겹살 (pork BBQ), 강남 카페 (Gangnam cafe). Reviews are then scraped from every matching place. Korean terms match best. One term per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationQuery": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "Optional area to restrict the search to, e.g. \"Gangnam, Seoul\" or \"강남구\". Resolved to a map area via OpenStreetMap. Leave empty to search all of Naver Maps for the term."
                    },
                    "province": {
                        "title": "🗺 Province / Metropolitan city (시·도)",
                        "type": "string",
                        "description": "Korea's top administrative tier (시/도) — a special/metropolitan city or a province. e.g. \"Seoul\" (서울특별시), \"Busan\" (부산광역시)."
                    },
                    "municipality": {
                        "title": "🏙 City / County / District (시·군·구)",
                        "type": "string",
                        "description": "Korea's municipal tier (시/군/구) — a district (구), city (시) or county (군). e.g. \"Gangnam-gu\" (강남구), \"Suwon-si\" (수원시)."
                    },
                    "neighborhood": {
                        "title": "📍 Town / Neighborhood (읍·면·동)",
                        "type": "string",
                        "description": "Korea's sub-municipal tier (읍/면/동) — a neighborhood (동), town (읍) or township (면). e.g. \"Yeoksam-dong\" (역삼동)."
                    },
                    "postalCode": {
                        "title": "📮 Postal code (우편번호)",
                        "type": "string",
                        "description": "5-digit Korean postal code (우편번호). e.g. \"06236\"."
                    },
                    "customBounds": {
                        "title": "🛰 Custom search area",
                        "type": "array",
                        "description": "Exact bounding box as [minLng, minLat, maxLng, maxLat]. Highest priority for search — overrides 📍 Location and the structured fields. Coordinate order is longitude first."
                    },
                    "maxPlacesPerSearch": {
                        "title": "💯 Max places per search term",
                        "minimum": 1,
                        "type": "integer",
                        "description": "When discovering places by search, the maximum number of places to collect per term (reviews are then scraped from each). Ignored in URL / ID mode.",
                        "default": 20
                    },
                    "maxReviewsPerPlace": {
                        "title": "⭐ Max reviews per place",
                        "minimum": 1,
                        "type": "integer",
                        "description": "The maximum number of reviews to scrape from each place. Reviews come newest-first. Set high to pull a place's entire review history. Split across the enabled review sources below.",
                        "default": 100
                    },
                    "reviewSources": {
                        "title": "Review type",
                        "enum": [
                            "both",
                            "visitor",
                            "blog"
                        ],
                        "type": "string",
                        "description": "Which Naver reviews to scrape. Naver has two kinds: Visitor reviews (방문자 리뷰) written on the place page, and Blog & café reviews (블로그·카페 리뷰) — external Naver Blog/Café posts linked to the place.",
                        "default": "both"
                    },
                    "includePersonalData": {
                        "title": "Include reviewer personal data",
                        "type": "boolean",
                        "description": "Include the reviewer's identity — nickname, profile URL and photo (and the blog author's name / blog for blog reviews). Personal data may be protected by law (e.g. GDPR); turn this off to omit reviewer identity from the output.",
                        "default": true
                    },
                    "language": {
                        "title": "🌍 Language",
                        "enum": [
                            "ko",
                            "en",
                            "ja",
                            "zh"
                        ],
                        "type": "string",
                        "description": "Preferred response language for review content and place info, where Naver provides it.",
                        "default": "ko"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```