# Naver Map Scraper (`crawlerbros/naver-map-scraper`) Actor

Search places by keyword or fetch specific places by URL, and get full business details: address, phone, hours, menus, photos, amenities, transit access, and review metrics. No login, no API key, and no paid proxy required.

- **URL**: https://apify.com/crawlerbros/naver-map-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Lead generation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Map Scraper

Scrape **Naver Map** — South Korea's dominant local-search and maps platform. Search places by keyword or fetch specific places by URL, and get full business details: address, phone, hours, menus, photos, amenities, transit access, and review metrics. No login, no API key, and no paid proxy required.

### What this actor does

- **Two modes:** `search` (keyword-based discovery) and `byUrls` (fetch specific places you already know)
- **Broad category coverage:** restaurants, cafes, bars, hotels, gyms, and general businesses, plus medical/dental clinics and hair/nail salons — Naver Map routes those verticals through separate endpoints, which this actor detects and handles automatically
- **Rich detail enrichment:** business hours by day, full menu with prices and photos, amenities, nearby subway/bus stations, photo gallery
- **Review signals:** visitor review count/score, blog & cafe review count, save count — all included by default (no extra request)
- **Filters:** category, minimum review score, minimum review count, open-now, has-booking
- **Empty fields are omitted** — every record only contains fields Naver Map actually returned for that place

### Output per place

- `placeId`, `name`, `category`, `businessCategory`, `categoryCodeList`
- `roadAddress`, `address`, `commonAddress`, `fullAddress`
- `x`, `y` (coordinates), `distance` (from search origin, `search` mode only)
- `phone`, `virtualPhone`, `hasMobilePhoneNumber`
- `talktalkUrl`, `chatBotUrl`, `routeUrl`, `placeUrl`, `homepageUrl` (mode `includeDetails=true`)
- `businessHoursStatus`, `businessHoursDescription` — quick status (e.g. "Open now")
- `businessHours[]` — full weekly schedule (mode `includeDetails=true`)
- `conveniences[]`, `paymentInfo[]`, `description`, `businessDescription` (long-form owner write-up, mode `includeDetails=true`), `microReview`
- `imageUrl`, `imageUrls[]`, `imageCount`, `detailPhotos[]`, `visitorImages[]` (photos from visitor reviews), `totalImageCount`, `panoramaUrl`, `staticMapUrl` (mode `includeDetails=true` for the last four)
- `visitorReviewCount`, `visitorReviewScore`, `blogCafeReviewCount`, `totalReviewCount`, `saveCount`
- `reviewImageCount`, `reviewAuthorCount`, `reviewThemes[]`, `reviewKeywords[]` — review-analysis breakdown (topics and voted tags with mention counts, mode `includeDetails=true`)
- `hasBooking`, `bookingUrl`, `bookingBusinessId`, `bookingReviewCount`, `naverBookingCategory`
- `hasNPay`, `newOpening`, `hasWheelchairEntrance`, `promotionTitle`, `broadcasts[]` (TV features), `michelinGuide`
- `naverOrder` — delivery/table-order/pre-order/pickup flags, only present when supported
- `businessToolsUsing[]` — active Naver business tools (e.g. `naverBooking`, `smartOrder`, `smartCall`), mode `includeDetails=true`
- `coupons[]`, `couponCount` — active promotion titles and count
- `posInsights` — popular menu, average spend, and average stay time (search results)
- `posSalesCount`, `posPopularDay`, `posAveragePrice` (by meal period), `posPopularMenus[]` — richer POS breakdown (mode `includeDetails=true`, where the business shares POS data)
- `menus[]` — name, price, description, photo, recommended flag (mode `includeDetails=true`)
- `facilities[]`, `keywords[]`, `parkingInfo`, `petFriendly`, `noKidsZone`, `subwayStations[]`, `busStations[]`, `relatedLinks[]` (external listing sites) (mode `includeDetails=true`)
- `recordType: "place"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` or `byUrls` |
| `searchKeywords` | array | `["강남 맛집"]` | Keywords to search (mode=search). Include a region/neighborhood name for local results. |
| `placeUrls` | array | – | Naver Map place URLs to fetch directly (mode=byUrls). Accepts full desktop, mobile, and `naver.me` short links. |
| `category` | string | – | Only keep places whose category contains this text (e.g. `카페`, `한식`) |
| `maxResultsPerKeyword` | int | `20` | Cap per keyword (1–100, Naver's real ceiling), mode=search |
| `includeDetails` | boolean | `true` | Fetch the place detail page for hours, menus, amenities, photos, transit |
| `includeReviews` | boolean | `false` | Emit embedded visitor reviews as separate records (mode=search only; see FAQ) |
| `maxReviewsPerPlace` | int | `50` | Cap on reviews fetched per place when `includeReviews` is on |
| `minVisitorReviewScore` | number | – | Only keep places at/above this review score (0–5) |
| `minVisitorReviewCount` | int | – | Only keep places with at least this many visitor reviews |
| `openNow` | boolean | `false` | Only keep places currently marked open |
| `hasBooking` | boolean | `false` | Only keep places with online booking |
| `maxItems` | int | `100` | Hard cap on total emitted records (1–5000) |
| `proxyConfiguration` | object | `{"useApifyProxy": true}` | Optional — Naver Map works without proxy for most traffic |

#### Example: search a neighborhood for top-rated cafes

```json
{
  "mode": "search",
  "searchKeywords": ["이태원 카페"],
  "maxResultsPerKeyword": 30,
  "category": "카페",
  "minVisitorReviewScore": 4.5,
  "includeDetails": true
}
```

#### Example: fetch specific places you already know

```json
{
  "mode": "byUrls",
  "placeUrls": [
    "https://pcmap.place.naver.com/restaurant/2020647783/home",
    "https://naver.me/xxxxxx"
  ],
  "includeDetails": true
}
```

#### Example: fast bulk discovery without detail pages

```json
{
  "mode": "search",
  "searchKeywords": ["강남 맛집", "홍대 맛집", "부산 해운대 맛집"],
  "maxResultsPerKeyword": 50,
  "includeDetails": false,
  "maxItems": 150
}
```

#### Example: only currently-open bookable restaurants

```json
{
  "mode": "search",
  "searchKeywords": ["신촌 맛집"],
  "openNow": true,
  "hasBooking": true
}
```

### Scope / Limitations

- **Hair/nail salon results don't include a native `category` value from Naver** (that vertical's data simply doesn't carry one) — the actor fills in `미용실`/`네일샵` respectively so the `category` filter still works for them, but a few other business-metadata fields common on restaurants (e.g. `posInsights`, `saveCount`) aren't available for this vertical because Naver doesn't return them there.
- **`includeReviews` returns only a few reviews per place** (typically 2–3), sourced from the same search response the rest of the record comes from. Naver's dedicated deep review-pagination endpoint applies bot-detection to repeated automated requests, so this actor intentionally does not use it — review *counts and scores* remain fully reliable regardless.
- **`category` is a substring filter**, not a structured taxonomy lookup — it matches against whatever category string Naver assigned the place (which can be compound, e.g. `카페,디저트`).
- **No standalone "browse by category" mode.** Naver Map's category browsing requires either a keyword or map bounds; use a keyword plus the `category` filter to approximate this.
- **100 results per keyword is the real, reliable ceiling.** Naver's list page only exposes deeper pagination through an endpoint that applies bot-detection to automated requests; use multiple/narrower keywords (e.g. by neighborhood) for broader coverage instead of expecting one keyword to return thousands of results.
- **Reviews (mode=search only).** `includeReviews` produces `recordType: "review"` records in the same dataset, each with `placeId`, `sourceUrl`, `reviewId`, `content`. Not available in `byUrls` mode.

### Use cases

- **Local SEO & marketing agencies** — audit business listings, hours, and review scores for clients across Korea
- **Restaurant/cafe discovery apps** — bulk-import venue data with menus, photos, and transit access
- **Market research** — analyze review volume and ratings across a neighborhood or category
- **Real estate & site selection** — evaluate foot-traffic proxies (review counts) and nearby transit for a location
- **Travel content** — build curated guides with real business hours, menus, and coupon data

### FAQ

**Is this affiliated with Naver?**
No. This is an independent, third-party actor that reads Naver Map's public search and place pages. It is not affiliated with or endorsed by Naver Corporation.

**Do I need a Naver account or API key?**
No. The actor reads the same public pages your browser loads when you search Naver Map — no login, cookies, or API key required.

**Why are some fields missing on some places?**
Naver Map only returns the fields a business has actually filled in. A place without a booking system won't have `bookingUrl`; a place without a menu photo won't have `menus[].images`. Empty fields are omitted rather than sent as `null`.

**What does `includeDetails=false` skip?**
Full weekly business hours, menus, amenities/facilities, nearby transit, and the extended photo gallery. Core fields (address, phone, review counts, coupons, business-hours status) are still included from the search results.

**How many reviews does `includeReviews` return per place?**
Up to a few (usually 2–3) real visitor reviews per place, sourced from the same search response — no extra request needed, so it's always reliable. Naver's separate, deeper review-pagination endpoint applies bot-detection to repeated automated requests, so this actor deliberately does not use it; review *counts and scores* (via the core fields, always included) remain the reliable way to gauge review volume beyond what individual review text is available for.

**How does `category` filtering work?**
It's a substring match against the place's Naver-assigned category (e.g. `카페`, `한식`, `요리주점`). Leave it blank to get every category returned by your keyword.

**Can I search in English?**
Yes, but results are far better with Korean keywords, since Naver Map is primarily indexed in Korean. Including a Korean neighborhood/region name in the keyword significantly improves relevance.

**Is a proxy required?**
No. Naver Map's search and detail pages work over the default (free) Apify proxy configuration. The `proxyConfiguration` input is available if you want to route traffic differently, but it's optional.

# Actor input Schema

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

What to fetch.

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

Keywords to search on Naver Map, e.g. `강남 맛집` (Gangnam restaurants) or `이태원 카페` (Itaewon cafes). Include a region name in the keyword for local results.

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

Naver Map place URLs to fetch directly. Accepts full desktop links (pcmap.place.naver.com), mobile links (m.place.naver.com), and short links (naver.me).

## `category` (type: `string`):

Only keep places whose category contains this text (e.g. `한식`, `카페`, `Cafe`). Leave blank for all categories.

## `maxResultsPerKeyword` (type: `integer`):

Hard cap on places emitted per search keyword (mode=search). 100 is Naver's real per-keyword ceiling for reliable, captcha-free results — use more/narrower keywords (e.g. by neighborhood) for broader coverage rather than raising this past 100.

## `includeDetails` (type: `boolean`):

Fetch the place detail page for full business hours, menus, amenities, photos, and transit info. Slower but much richer data.

## `includeReviews` (type: `boolean`):

Emit a few real visitor reviews per place (typically 2-3, no extra request needed) as separate `recordType: "review"` records. Naver's deep review-pagination endpoint applies bot-detection to automated requests, so only the reviews already present in search results are used. Mode=search only — silently has no effect in mode=byUrls, since byUrls has no embedded reviews to draw from.

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

Cap on the (typically 2-3 available) reviews emitted per place when Include reviews is on.

## `minVisitorReviewScore` (type: `number`):

Only keep places with a visitor review score at or above this value (0-5). Leave blank for no filter.

## `minVisitorReviewCount` (type: `integer`):

Only keep places with at least this many visitor reviews. Leave blank for no filter.

## `openNow` (type: `boolean`):

Only keep places currently marked as open by Naver Map.

## `hasBooking` (type: `boolean`):

Only keep places that support online booking/reservations through Naver.

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

Hard cap on total emitted place records across all keywords/URLs.

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

Optional. Naver Map does not require proxy for most traffic; enable if you see request failures.

## Actor input object example

```json
{
  "mode": "search",
  "searchKeywords": [
    "강남 맛집"
  ],
  "placeUrls": [],
  "maxResultsPerKeyword": 20,
  "includeDetails": true,
  "includeReviews": false,
  "maxReviewsPerPlace": 10,
  "openNow": false,
  "hasBooking": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `places` (type: `string`):

Dataset containing all scraped Naver Map places.

# 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 = {
    "mode": "search",
    "searchKeywords": [
        "강남 맛집"
    ],
    "placeUrls": [],
    "maxResultsPerKeyword": 20,
    "includeDetails": true,
    "includeReviews": false,
    "maxReviewsPerPlace": 10,
    "openNow": false,
    "hasBooking": false,
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/naver-map-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 = {
    "mode": "search",
    "searchKeywords": ["강남 맛집"],
    "placeUrls": [],
    "maxResultsPerKeyword": 20,
    "includeDetails": True,
    "includeReviews": False,
    "maxReviewsPerPlace": 10,
    "openNow": False,
    "hasBooking": False,
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/naver-map-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 '{
  "mode": "search",
  "searchKeywords": [
    "강남 맛집"
  ],
  "placeUrls": [],
  "maxResultsPerKeyword": 20,
  "includeDetails": true,
  "includeReviews": false,
  "maxReviewsPerPlace": 10,
  "openNow": false,
  "hasBooking": false,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/naver-map-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/3bECEmOhgjtKwXN7p/builds/nmQH4uai0eYOh5k9a/openapi.json