# Naver Map Scraper: Korean Local Business Data (`thescrapelab/naver-map-scraper`) Actor

Scrape public Naver Map business data—places, menus, prices, hours, contacts, and photos—from Korean keywords or place URLs. No API key or login.

- **URL**: https://apify.com/thescrapelab/naver-map-scraper.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** SEO tools, Marketing, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 detailed business records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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: Korean Local Business Data

Turn Naver Map into structured local-business intelligence—without a Naver API key, account, or login. Enter Korean keywords such as `강남 맛집` (Gangnam restaurants) or `홍대 카페` (Hongdae cafés), or provide specific Naver Map URLs, and receive detailed public business data ready to use.

Use it to build Korea-focused lead lists, compare local competitors, and track public menus, prices, and business information.

### Why use this Actor?

- Find public Naver Map businesses by keyword or collect known businesses from direct URLs.
- Capture useful commercial fields in one dataset: address, phone, category, map coordinates, hours, menus, prices, facilities, photos, and website links when publicly rendered.
- Keep every run simple and predictable with safe built-in collection settings.
- Run entirely from Apify—no Naver API subscription, API key, account, or login required.

### Ideal for

- Local SEO and digital-marketing agencies researching Korean search visibility.
- Restaurant, retail, hospitality, beauty, medical, and franchise teams benchmarking local competitors.
- Sales and market-research teams building Korea-focused prospect lists.
- Analysts tracking public menus, pricing, business hours, and business details.

### Quick start

In the **Input** tab, provide at least one keyword in `searchKeywords` or at least one public Naver Map URL in `urls`.

#### Discover businesses by keyword

```json
{
  "searchKeywords": ["강남 맛집", "홍대 카페"]
}
```

#### Research one known business

```json
{
  "urls": ["https://naver.me/FqW0LLx9"]
}
```

Supported URL formats include public `map.naver.com` place and search-result links, `m.place.naver.com` business pages, and `naver.me` short links that redirect to a public Naver Map business.

### What happens automatically

The Actor is deliberately configured for a reliable, low-friction first run:

| Built-in setting | Default behavior |
| --- | --- |
| Keyword results | Collects up to 10 businesses for each keyword. |
| Business details | Collects detailed public place data, including menus, prices, hours, facilities, photos, and links where Naver renders them. |
| Reviews | Does not collect individual review content, keeping results fast and predictable. Public review totals and scores may still be returned when shown by Naver. |
| Reliability | Uses Apify Proxy, Chromium browser collection, and one retry automatically. |

Efficient collection defaults to 1024 MB memory with a 15-minute run limit. For larger jobs, set a maximum cost per run in the Console.

### Input reference

| Input | What it does |
| --- | --- |
| `searchKeywords` | Korean or English searches used to discover Naver Map businesses. |
| `urls` | Public Naver Map business URLs for precise lookups. |

That is the complete client input. The Actor uses safe collection, proxy, and retry settings automatically.
If a keyword and a direct URL resolve to the same business in one run, it is returned once.

### Output example

Every dataset row is one business. The fields depend on what Naver renders publicly, but a detailed output record can look like this:

```json
{
  "placeId": "1976543477",
  "name": "Example Restaurant",
  "category": "Restaurant",
  "roadAddress": "서울특별시 강남구 테헤란로 123",
  "phone": "02-1234-5678",
  "x": "127.0276",
  "y": "37.4979",
  "businessHours": [],
  "conveniences": ["Reservation", "Parking"],
  "menus": [
    {
      "name": "Signature Menu",
      "price": "25000",
      "description": "",
      "images": [],
      "recommend": true
    }
  ],
  "visitorReviewsTotal": 324,
  "visitorReviewsScore": 4.6,
  "sourceUrl": "https://m.place.naver.com/restaurant/1976543477/home",
  "scrapedAt": "2026-08-01T00:00:00.000Z"
}
```

`x` is longitude and `y` is latitude. The output tab provides:

- JSON for all dataset records.
- A CSV places overview with key contact and review-score fields.
- `RUN-STATS`, which records collection counts, warnings, errors, and pricing details for the run.

### Use from Python

Install the Apify client, then call the Actor and read its dataset:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
actor = client.actor("thescrapelab/naver-map-scraper")

run = actor.call(
    run_input={
        "searchKeywords": ["강남 맛집"]
    }
)

if run is None:
    raise RuntimeError("Actor run did not complete")

for business in client.dataset(run.default_dataset_id).iterate_items():
    print(business["name"], business.get("roadAddress"))
```

### Reliability, limits, and responsible use

- This Actor reads public Naver Map pages. It does not use a Naver API, credentials, login, cookies, or verification bypass.
- Naver may show a security-verification page or omit data for a business. The Actor reports and skips that page rather than attempting to circumvent the restriction.
- Search relevance, categories, and results are controlled by Naver. Use specific Korean queries or direct business URLs when precision matters.
- Only collect and use data in a way that complies with applicable laws, Naver's terms, and your legitimate business purpose.

### Cost control

No Naver API access is required. This Actor uses simple pay-per-result pricing rather than charging by compute usage:

| Billable event | Price |
| --- | ---: |
| Detailed business record | $0.004 each |

That is **$4 per 1,000 detailed businesses**, with no separate custom run-start charge. Apify automatically applies its standard `apify-actor-start` event ($0.00005 at the default 1 GB memory), so one direct business costs about $0.00405 and the default 10-business keyword run costs about $0.04005.

The minimum permitted maximum-cost limit is $0.005, enough for a run to start and return one detailed business. Each keyword can return up to 10 detailed business records, so start with one focused keyword or a single URL. Set a maximum cost per run in Apify Console before scaling. When a limit is reached, the Actor completes the currently paid item and stops before returning unpaid data.

### Troubleshooting and support

Use the run's `RUN-STATS` output first when a business is missing. For the most reproducible support request, include the input used, the run ID, and one affected public Naver Map URL—never account credentials.

# Actor input Schema

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

Korean or English local-business searches, for example 강남 맛집 (Gangnam restaurants) or 홍대 카페 (Hongdae cafés).

## `urls` (type: `array`):

Look up specific public businesses. Full map.naver.com, mobile m.place.naver.com, and naver.me short URLs are supported.

## Actor input object example

```json
{
  "searchKeywords": [
    "강남 맛집"
  ],
  "urls": []
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All detailed business records as JSON, with one business per dataset row.

## `datasetCsv` (type: `string`):

A simple CSV overview with one business per row.

## `runStats` (type: `string`):

Counts, warnings, and pricing details for this run.

# 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 = {
    "searchKeywords": [
        "강남 맛집"
    ],
    "urls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/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 = {
    "searchKeywords": ["강남 맛집"],
    "urls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/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 '{
  "searchKeywords": [
    "강남 맛집"
  ],
  "urls": []
}' |
apify call thescrapelab/naver-map-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/xmmQiVCXPScRngyjo/builds/lKb7RebFJFz5vAlw5/openapi.json