# NAVER Place Review Scraper (`parsebird/naver-place-review-scraper`) Actor

Scrape Naver Place reviews: visitor review text, star ratings, visit dates, voted keywords, owner replies, photos, and Naver Blog reviews. Export JSON, CSV, Excel.

- **URL**: https://apify.com/parsebird/naver-place-review-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Travel, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.89 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

# README

### Naver Place Review Scraper

Naver Place Review Scraper extracts public visitor reviews and Naver Blog reviews from [Naver Place](https://map.naver.com/) (네이버 플레이스), Korea's dominant local business and maps platform. Give it a Place URL, a bare Place ID, or a search keyword, and it returns structured review text, star ratings, visit dates, voted keywords, owner replies, photos, and aggregated rating statistics.

<table><tr>
<td style="border-left:4px solid #03C75A;padding:12px 16px;font-weight:600">
Scrape visitor reviews with star ratings and voted keywords, Naver Blog and Cafe posts linked to a place, and per-place rating statistics — from restaurants, cafes, hospitals, hotels, and any other Naver Place category.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```text
Use Apify Actor parsebird/naver-place-review-scraper to scrape public Naver Place (네이버 플레이스) visitor reviews and Naver Blog reviews. Example with ApifyClient: client.actor("parsebird/naver-place-review-scraper").call(run_input={"placeUrls":["https://map.naver.com/p/entry/place/11571707"],"maxReviewPages":3,"includeBlogReviews":True}), then read client.dataset(run["defaultDatasetId"]).iterate_items(). Key inputs: placeUrls array of Naver Place URLs or bare Place IDs, startUrls array alternative in [{"url":...}] format, searchKeywords array to find places by keyword, maxPlacesPerKeyword integer default 5, maxReviews integer optional cap that overrides maxReviewPages, maxReviewPages integer default 1 (50 reviews per page), reviewSort enum NEWEST/RANKING default NEWEST, includeBlogReviews boolean default true, maxBlogReviewPages integer default 10 (10 posts per page, Naver caps around 100), includeReviewPhotos boolean default false, includeReviewStats boolean default true, maxConcurrency integer default 5, proxyConfiguration object. Output fields include reviewType (visitor/blog/place_stats), placeId, placeName, placeCategory, placeAddress, placeRating, reviewText, reviewRating, reviewerName, reviewerProfileUrl, reviewDate, visitDate, visitCount, votedKeywords, visitCategories, reviewPhotos, reviewReplyText, blogTitle, blogContents, blogUrl, bloggerName, blogDate, averageRating, starDistribution, topVotedKeywords, searchKeyword, scrapedAt. API docs: https://docs.apify.com/api/client/python/ and https://docs.apify.com/api/client/js/. Token: https://console.apify.com/account/integrations.
```

### What does Naver Place Review Scraper do?

**Naver Place Review Scraper** collects public review data from [Naver Place](https://map.naver.com/), the review and local-business layer behind Naver Map that most Korean consumers check before visiting a restaurant, cafe, clinic, salon, or attraction. Use it to monitor review sentiment, benchmark competitors, feed review data into NLP or LLM pipelines, or build datasets for market research on any Korean local business.

- 📍 Accept three input modes: **Place URLs**, bare **Place IDs**, or **search keywords** — mix and match in the same run.
- ⭐ Extract visitor review text, star rating, visit date, visit count, and reviewer profile info.
- 🏷️ Capture Naver's **voted keywords** (e.g. "음식이 맛있어요") and visit-context tags attached to each review.
- 💬 Pull the business owner's public reply text and reply date when present.
- 📷 Optionally include review photo URLs.
- 📝 Scrape linked **Naver Blog** and **Naver Cafe** posts about the place, including title, excerpt, and blogger info.
- 📊 Generate a per-place statistics row: average rating, star distribution, and top voted keywords.
- 🔎 Search by Korean or English keyword (e.g. `강남 맛집` or `Seoul BBQ`) to discover places before scraping their reviews.
- ⚡ Run places concurrently, with adjustable concurrency and residential proxy support for reliable access at scale.
- 📤 Send results to [Apify integrations](https://apify.com/integrations), the [Apify API](https://docs.apify.com/api/v2), webhooks, databases, or spreadsheets, and download JSON, CSV, or Excel.

### What data can you extract from Naver Place?

| Field | Description |
|-------|-------------|
| `reviewText` | Full visitor review body (Korean) |
| `reviewRating` | Star rating, 1–5 |
| `reviewerName` | Reviewer nickname, profile URL, and total review count |
| `reviewDate` / `visitDate` | Review creation date and actual visit date (ISO `YYYY-MM-DD`) |
| `visitCount` / `visitCountLabel` | Visit number, e.g. "3번째 방문" (3rd visit) |
| `votedKeywords` | Naver's voted review tags, e.g. "음식이 맛있어요", "분위기가 좋아요" |
| `visitCategories` | Visit-context tags such as wait time and reservation method |
| `reviewPhotos` | Photo URLs attached to the review (optional) |
| `reviewReplyText` | Business owner's public reply |
| `blogTitle` / `blogContents` / `blogUrl` | Naver Blog or Cafe post title, excerpt, and link |
| `bloggerName` | Blog or cafe author name |
| `averageRating` / `starDistribution` | Aggregated place rating and 5★–1★ breakdown |
| `topVotedKeywords` | Most common voted keywords across all reviews, with counts |

### How to scrape Naver Place reviews

1. Open [Naver Place Review Scraper](https://apify.com/parsebird/naver-place-review-scraper) on Apify.
2. Add one or more **Place URLs** (e.g. `https://map.naver.com/p/entry/place/11571707`) or bare **Place IDs** in `placeUrls`. Short `naver.me` links are resolved automatically.
3. Or leave `placeUrls` empty and add **search keywords** to `searchKeywords`, such as `강남 맛집` or `Seoul BBQ`; the actor finds matching places and scrapes their reviews.
4. Set `maxReviewPages` (50 reviews per page) or `maxReviews` for an exact cap. Keep the value low for a fast, cheap test run.
5. Toggle `includeBlogReviews` and `includeReviewStats` depending on which review types you need.
6. Enable a proxy in `proxyConfiguration` for large or repeated runs to avoid Naver rate limiting.
7. Run the actor, open the dataset, and export results as JSON, CSV, or Excel, or connect them through the Apify API.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `placeUrls` | array | No | Prefilled with 1 place | Naver Place URLs or plain Place IDs |
| `startUrls` | array | No | `[]` | Alternative `[{"url": "..."}]` input format for integrations |
| `searchKeywords` | array | No | `[]` | Keywords to search for places, then scrape their reviews |
| `maxPlacesPerKeyword` | integer | No | `5` | Max places to take from each keyword search (1–50) |
| `maxReviews` | integer | No | — | Max visitor reviews per place; overrides `maxReviewPages` when set (1–50,000) |
| `maxReviewPages` | integer | No | `1` | Visitor review pages per place, 50 reviews per page (1–1,000) |
| `reviewSort` | string | No | `NEWEST` | `NEWEST` or `RANKING` (Naver's own recommendation order) |
| `includeReviewPhotos` | boolean | No | `false` | Include photo URLs attached to each visitor review |
| `includeBlogReviews` | boolean | No | `true` | Also collect linked Naver Blog / Cafe posts |
| `maxBlogReviewPages` | integer | No | `10` | Blog review pages per place, 10 posts per page (1–100) |
| `includeReviewStats` | boolean | No | `true` | Add one aggregated rating-statistics row per place |
| `maxConcurrency` | integer | No | `5` | Places to scrape in parallel (1–10) |
| `proxyConfiguration` | object | No | Apify proxy | Proxy settings; recommended for large runs |

### Output example

Visitor review:

```json
{
  "reviewType": "visitor",
  "placeId": "11571707",
  "placeName": "경복궁",
  "placeCategory": "궁궐",
  "placeAddress": "서울 종로구 사직로 161 경복궁",
  "placeRating": 4.69,
  "placeTotalReviews": 12514,
  "placeUrl": "https://pcmap.place.naver.com/place/11571707",
  "reviewId": "6a786af0d4bfe92dced69067",
  "reviewText": "서울여행 가족들과 경복궁 나들이! 한복을 입고 가면 무료입장...",
  "reviewRating": 5,
  "reviewerName": "Marge simpson 0410",
  "reviewerProfileUrl": "https://m.place.naver.com/my/5fd063c7b421d3204bb3eb2a/review?v=2",
  "reviewerReviewCount": 391,
  "reviewDate": "2026-08-09",
  "visitDate": "2026-08-09",
  "votedKeywords": ["사진이 잘 나와요", "볼거리가 많아요", "뷰가 좋아요"],
  "reviewReplyText": null,
  "searchKeyword": null,
  "language": "ko",
  "scrapedAt": "2026-08-10T22:26:16.443959Z"
}
```

Blog review:

```json
{
  "reviewType": "blog",
  "placeId": "1743025750",
  "placeName": "포비 강남점",
  "blogTitle": "고터 파미에스테이션 카페 포비 FOURB",
  "blogContents": "카페명: 포비 강남 FOURB. 베이글 맛집으로 유명한, 호불호는 있을 듯!",
  "blogUrl": "https://m.cafe.naver.com/cafeflex/22617",
  "bloggerName": "아메리카노",
  "blogDate": "2022-08-07",
  "scrapedAt": "2026-08-10T22:26:16.443959Z"
}
```

Download results in JSON, CSV, Excel, HTML, or XML directly from the [Apify dataset](https://docs.apify.com/platform/storage/dataset), or read them through the API.

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("parsebird/naver-place-review-scraper").call(run_input={
    "placeUrls": ["https://map.naver.com/p/entry/place/11571707"],
    "maxReviewPages": 3,
    "includeBlogReviews": True,
    "includeReviewStats": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["reviewType"], item.get("reviewText") or item.get("blogTitle"))
```

See the official [Apify Python client documentation](https://docs.apify.com/api/client/python/) for authentication and dataset options.

### JavaScript API example

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('parsebird/naver-place-review-scraper').call({
  searchKeywords: ['강남 맛집'],
  maxPlacesPerKeyword: 5,
  maxReviewPages: 1,
});

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

See the official [Apify JavaScript client documentation](https://docs.apify.com/api/client/js/) for more examples.

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

**What is the price per Naver Place review?**

| Event | Free | Bronze | Silver | Gold |
|-------|------|--------|--------|------|
| `review-scraped` | $0.00099 (**$0.99 / 1,000**) | $0.00089 (**$0.89 / 1,000**) | $0.00089 (**$0.89 / 1,000**) | $0.00089 (**$0.89 / 1,000**) |

Each `review-scraped` event means one visitor review or blog review was pushed to the dataset. Place statistics rows are not charged. Scraping 500 visitor reviews (`maxReviewPages: 10`) from one place costs about $0.45–$0.50. Apify's free trial credits cover small test runs.

### Use cases

- Monitor review sentiment and rating trends for a restaurant, cafe, salon, clinic, or hotel over time.
- Benchmark competitor ratings, voted keywords, and review volume across multiple Naver Place listings.
- Feed Korean review text into NLP or LLM pipelines for sentiment analysis or summarization.
- Build local-business or franchise datasets for market research and site-selection analysis.
- Track owner responsiveness by monitoring `reviewReplyText` and `reviewReplyDate` over scheduled runs.
- Discover and evaluate places by keyword, such as sourcing candidates for a "best of" list.

### How it works

1. The actor resolves each input into a numeric Naver Place ID, following short `naver.me` links when needed, or runs keyword searches against Naver's public place-search API.
2. It fetches place details (name, category, address, rating totals) for context on every review.
3. It pages through visitor reviews using Naver's cursor-based pagination until the requested count or page limit is reached.
4. If enabled, it separately pages through linked Naver Blog and Naver Cafe posts using offset-based pagination.
5. It normalizes Korean date formats, voted keywords, and reviewer info into a stable dataset schema.
6. It pushes each review to the Apify dataset and applies PPE charging only on the Apify platform, stopping automatically if the user's spending limit is reached.

### Is it legal to scrape Naver Place?

**Is scraping Naver Place reviews legal?**

Scraping publicly available web data is generally allowed in many jurisdictions, but you should review Naver's terms of service, avoid collecting private or sensitive information, and make sure your use case complies with applicable laws. For background, read Apify's guide: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

### Other scrapers / Related Actors

| Actor | Best for |
|-------|----------|
| [Naver Place Review Scraper](https://apify.com/parsebird/naver-place-review-scraper) | Naver Place visitor reviews, blog reviews, and rating statistics |
| [GetYourGuide Review Scraper](https://apify.com/parsebird/getyourguide-review-scraper) | Tour and activity review data with ratings and text |
| [Website Contact Finder](https://apify.com/parsebird/website-contact-finder) | Finding public contact details for a business or lead list |
| [Shopify Store Leads Scraper](https://apify.com/parsebird/shopify-store-leads-scraper) | Finding Shopify stores and ecommerce leads |
| [Google Ads Transparency Center Scraper](https://apify.com/parsebird/google-ads-transparency-scraper) | Competitor ad research and monitoring |

### FAQ

**Can I use this as a Naver Place review API?**

Yes. Start runs and fetch datasets through the [Apify API](https://docs.apify.com/api/v2), Python client, JavaScript client, webhooks, or integrations.

**Can I scrape reviews for a place I only know by name?**

Yes. Add the place name or a location-plus-category phrase to `searchKeywords` (e.g. `강남 맛집`), and the actor finds matching places before scraping their reviews.

**Does this actor accept short naver.me links?**

Yes. `placeUrls` resolves `naver.me` short links to a Place ID automatically.

**How many reviews can I collect per place?**

Set `maxReviews` for an exact cap (up to 50,000) or `maxReviewPages` for page-based control (50 reviews per page, up to 1,000 pages). Naver's blog review feed is capped at roughly 100 posts per place regardless of `maxBlogReviewPages`.

**Why is `reviewReplyText` empty for most reviews?**

Only a minority of Naver Place reviews receive a public owner reply. The field is `null` when no reply exists.

**Does this actor require a proxy?**

A proxy is recommended for large or repeated runs to avoid Naver rate limiting. The input schema defaults to Apify proxy settings.

**Can I schedule recurring review monitoring?**

Yes. Use [Apify schedules](https://docs.apify.com/platform/schedules) to run this Naver Place scraper daily, weekly, or at any interval and track rating changes over time.

**Where can I report issues or request fields?**

Open the Issues tab on the actor page and include your input example, run ID, and the Naver Place URL or ID.

# Actor input Schema

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

Add Naver Place URLs or plain Place IDs. Examples: https://map.naver.com/p/entry/place/11571707 or 11571707. Short naver.me links are resolved automatically.

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

Alternative input format for integrations: \[{"url": "https://map.naver.com/p/entry/place/11571707"}]. Use Place URLs or IDs for simpler input.

## `searchKeywords` (type: `array`):

Add Naver Place search keywords, such as 강남 맛집 or Seoul BBQ. The actor finds matching places and scrapes their reviews.

## `maxPlacesPerKeyword` (type: `integer`):

Maximum number of places to take from each keyword search.

## `maxReviews` (type: `integer`):

Maximum visitor reviews to collect per place. Overrides Max review pages when set. Leave empty to use Max review pages instead.

## `maxReviewPages` (type: `integer`):

Visitor review pages to fetch per place, 50 reviews per page. Set 1 for ~50 reviews, 10 for ~500. Ignored when Max visitor reviews per place is set.

## `reviewSort` (type: `string`):

Order visitor reviews. NEWEST returns the most recent reviews first. RANKING asks Naver for its recommendation order, which Naver currently applies only to places that expose it.

## `includeReviewPhotos` (type: `boolean`):

Add the photo URLs attached to each visitor review. The photo count is always included.

## `includeBlogReviews` (type: `boolean`):

Also collect the Naver Blog and Naver Cafe posts linked to each place.

## `maxBlogReviewPages` (type: `integer`):

Blog review pages to fetch per place, 10 posts per page. Naver caps this feed at roughly 100 posts per place.

## `includeReviewStats` (type: `boolean`):

Add one statistics row per place with the average rating, star distribution, and top voted keywords.

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

How many places to scrape in parallel. Higher is faster for multi-place runs but raises the rate-limit risk without a proxy.

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

Proxy settings. Recommended for large runs to avoid rate limiting.

## Actor input object example

```json
{
  "placeUrls": [
    "https://map.naver.com/p/entry/place/11571707"
  ],
  "startUrls": [],
  "searchKeywords": [],
  "maxPlacesPerKeyword": 3,
  "maxReviewPages": 1,
  "reviewSort": "NEWEST",
  "includeReviewPhotos": false,
  "includeBlogReviews": true,
  "maxBlogReviewPages": 2,
  "includeReviewStats": true,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "placeUrls": [
        "https://map.naver.com/p/entry/place/11571707"
    ],
    "startUrls": [],
    "searchKeywords": [],
    "maxPlacesPerKeyword": 3,
    "maxReviewPages": 1,
    "maxBlogReviewPages": 2,
    "maxConcurrency": 3,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/naver-place-review-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/11571707"],
    "startUrls": [],
    "searchKeywords": [],
    "maxPlacesPerKeyword": 3,
    "maxReviewPages": 1,
    "maxBlogReviewPages": 2,
    "maxConcurrency": 3,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/naver-place-review-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 '{
  "placeUrls": [
    "https://map.naver.com/p/entry/place/11571707"
  ],
  "startUrls": [],
  "searchKeywords": [],
  "maxPlacesPerKeyword": 3,
  "maxReviewPages": 1,
  "maxBlogReviewPages": 2,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call parsebird/naver-place-review-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/naver-place-review-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/ZtLlLDi6p9JKRkxr8/builds/V69IZl22duHH13AKw/openapi.json
