# Naver Place Scraper — Korean Local Business Leads (`foxlabs/naver-place-scraper`) Actor

Korean local businesses from Naver Place (네이버 플레이스) by keyword + region: name, category, address, coordinates, phone, business hours, review count/score and digital-booking flags (reservation, N-Pay). 100 records per request.

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

## Pricing

from $2.50 / 1,000 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Naver Place Scraper — Korean Local Business Leads 📍

**More Fox Labs data actors:** **[Fox Labs on Apify →](https://apify.com/foxlabs)**

🎉 Pull Korean local businesses from **Naver Place (네이버 플레이스)** by keyword + region — name, phone, address, hours, coordinates, ratings and digital-booking flags — with no login and no API key.
Built for local lead-gen & sales teams, franchise and site-selection analysts, and POS/SaaS vendors targeting Korean SMBs.

### 🔍 What is the Naver Place Scraper — and when should you use it?

In Korea, Naver Place is where local businesses live — the maps, reviews and booking layer that Korean customers actually use. This actor searches it for you: give it a Korean phrase like `강남 카페` (Gangnam cafes) or `부산 병원` (Busan hospitals) and it returns the top businesses for that query with their full public profile — name, category, phone, road address, business hours, coordinates, visitor/blog review counts and score, and whether the business uses Naver booking or N-Pay.

It reads Naver Place's own server-rendered page data, so there is **no token to manage and no login** — which keeps it robust when Naver changes its internals.

**Use it when you need:** a phone + address list for a business category in a district; competitor density, ratings and review counts by area; businesses that already use Naver booking / N-Pay (qualified POS/SaaS leads); or coordinates for mapping a local market.

**Use something else when:** you need every business in a huge city in one call. This actor returns the top results Naver Place shows for a query (about 50–60 per search); for wide coverage, run several **district-level** queries (`강남 미용실`, `서초 미용실`, `송파 미용실` …) rather than one broad one.

### 🤖 Use with AI agents

**Already on the Apify MCP server?** Ask for this Actor by name: `foxlabs/naver-place-scraper`.

**Your agent can pay for its own runs.** This Actor is pay-per-event with agentic payments, so an agent can discover it, run it and settle the bill over **x402 (USDC on Base)** or **Skyfire** — no Apify account or API token of its own. Billing is the same either way: per delivered business, never for errors.

Otherwise paste this into Claude, ChatGPT, Cursor or any MCP-enabled assistant:

```
I want Korean local businesses from Naver Place using the Apify Actor
`foxlabs/naver-place-scraper`.

Input: `queries` is a list of Korean search phrases, each a region + category,
e.g. "강남 카페" (Gangnam cafes), "부산 병원" (Busan hospitals), "강남 미용실" (Gangnam hair salons).
Optional: `maxRecordsPerQuery` (default 100 — Naver shows ~50–60 top results per query),
`enrichDetail` (true/false — for sparse verticals like hair salons the phone is not in the list,
so fetch each detail page to recover it).
Each row has name, category, phone, address, businessHours, lat, lng, visitorReviewCount,
visitorReviewScore, hasBooking, hasNPay, bookingUrl, placeUrl.

Start with:
{ "queries": ["강남 카페"], "maxRecordsPerQuery": 100 }

Ask me which city/district and category I care about, run the Actor, then summarise the
businesses as a table with phone and rating.
```

Things you can ask your agent for:

- "List Gangnam cafes with their phone, rating and review count."
- "Which hospitals in Busan take Naver bookings?"
- "Pull hair salons across three Seoul districts and dedupe them into one sheet."

The machine-readable API, MCP config and OpenAPI definition live at `apify.com/foxlabs/naver-place-scraper.md`.

### 📋 Overview

Everything you need to turn Naver Place into a clean Korean local-business dataset — contact, location, ratings and booking signals — in one actor, with no login, cookies or API key.

**Why teams pick this actor:**

- 🔑 **No login, no API key, no token** — reads Naver Place's own server-rendered data.
- 📞 **The fields a lead wants** — phone, road address, hours, coordinates, ratings and review counts.
- 💳 **Buying signals built in** — `hasBooking` and `hasNPay` flag businesses already digitised (ideal POS/SaaS leads).
- 🌏 **Any vertical, one input** — cafes, hospitals, hair salons, dentists, gyms, hotels, pharmacies… just change the Korean phrase.
- 🧹 **Clean, vertical-independent schema** — same columns whatever you search; coordinates as numbers, no empty-promise fields.
- 💰 **Pay only for results** — per-business pricing; empty searches are never billed.
- 🤖 **Agent-ready** — MCP + x402 agentic payments.

### ✨ Features

- 🔍 **Keyword + region search** across Naver Place — no business IDs needed.
- 📇 **Full public profile per business** — name, category, phone, address, hours, coordinates, review count/score, booking flags, image, place URL.
- 📞 **Phone enrichment** (`enrichDetail`) — for verticals that hide the phone in the list (e.g. hair salons), fetch the detail page to recover it.
- 🗺️ **Map-ready** — latitude/longitude as numbers on every row.
- 🛡️ **Robust by design** — reads server-rendered page state (no fragile token replay); runs a real browser through rotating datacenter proxy.

### 🎬 Quick Start

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~naver-place-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json; charset=utf-8" \
  --data-binary '{"queries": ["강남 카페"], "maxRecordsPerQuery": 100}'
```

(Send the body as UTF-8 so the Korean query is preserved.)

### 🚀 Getting Started (3 steps)

1. **Type your Korean queries** — one per line, each a region + category (`강남 카페`, `부산 병원`).
2. **Set the size (optional)** — `maxRecordsPerQuery`; turn on `enrichDetail` for sparse verticals like hair salons.
3. **Run and export** — get a clean dataset as JSON, CSV or Excel.

### 📥 Input

```json
{
  "queries": ["강남 카페", "부산 병원"],
  "maxRecordsPerQuery": 100,
  "enrichDetail": false
}
```

| Field | Type | Description |
|---|---|---|
| `queries` | array | Korean search phrases, one per line — each a region + category (`강남 카페`, `부산 병원`, `강남 미용실`). |
| `maxRecordsPerQuery` | integer | Caps businesses per query (default 100). Naver Place shows about 50–60 top results per query. |
| `enrichDetail` | boolean | For sparse verticals (e.g. hair salons) the phone is missing from the list; fetch each business's detail page to recover it. Adds one request per enriched business. |
| `proxyConfiguration` | object | Optional. Naver throttles raw and repeat requests, so the actor runs a real browser through Apify datacenter proxy with rotation by default. |

### 📤 Output

One row per business, saved to the dataset.

| Field | Type | Description |
|---|---|---|
| `name` | string | Business name |
| `category` | string | Naver category |
| `phone` | string | Phone (or Naver virtual number); for sparse verticals filled via `enrichDetail` |
| `address` | string | Road address |
| `businessHours` | object | Opening-hours status / description where Naver publishes it |
| `lat` / `lng` | number | Coordinates |
| `visitorReviewCount` / `visitorReviewScore` | number | Visitor review count and average score |
| `blogCafeReviewCount` / `bookingReviewCount` | number | Blog/cafe and booking review counts |
| `hasBooking` / `hasNPay` | boolean | Uses Naver booking / N-Pay |
| `bookingUrl` | string | Naver booking link where present |
| `imageUrl` | string | Representative photo |
| `placeUrl` | string | Naver Place page for the business |
| `id` | string | Naver Place ID |

Every row also carries `query`; enriched rows carry `phoneSource: "detail"`.

```json
{
  "query": "강남 카페",
  "id": "1498100901",
  "name": "그라운드8",
  "category": "카페",
  "phone": "0507-1302-6392",
  "address": "도산대로49길 41 2층",
  "businessHours": { "status": "영업 중", "description": "01:00에 라스트오더" },
  "lat": 37.5257026,
  "lng": 127.0369307,
  "visitorReviewCount": 423,
  "visitorReviewScore": 4.97,
  "hasBooking": false,
  "hasNPay": true,
  "placeUrl": "https://m.place.naver.com/place/1498100901/home"
}
```

### 💼 Use cases

**1. Local lead lists** — phone + address for a category in a district.
*Input:* `queries: ["강남 미용실"]`, `enrichDetail: true`. *Output:* salons with phone and rating. *Use:* outbound sales calling lists.

**2. POS / SaaS targeting** — businesses already digitised with Naver booking or N-Pay.
*Input:* `queries: ["강남 카페", "홍대 카페"]`. *Output:* rows flagged `hasBooking` / `hasNPay`. *Use:* prioritise accounts most likely to adopt payments/booking software.

**3. Franchise & site selection** — competitor density, ratings and review counts by area.
*Input:* the same category across several districts. *Output:* one table with coordinates and ratings. *Use:* map saturation and pick sites.

**4. Market research** — category coverage and sentiment by region.
*Input:* a category across target cities. *Output:* review counts/scores per business. *Use:* benchmark a local market.

### 🔗 Integration

**JavaScript / Node.js**

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('foxlabs/naver-place-scraper').call({
  queries: ['강남 카페'], maxRecordsPerQuery: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('foxlabs/naver-place-scraper').call(
    run_input={'queries': ['강남 카페'], 'maxRecordsPerQuery': 100}
)
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)
```

Written for `apify-client` 3 for Python, where `call()` returns a run object; with version 1 or 2 it returns a dict — write `run['defaultDatasetId']` there.

**Automation (n8n / Zapier / Make):** schedule or webhook → HTTP request to the actor API with your `queries` → handle the JSON dataset → push to a sheet, CRM or dashboard.

### 📊 Pricing

Pay-per-event:

- **$2.50 per 1,000 delivered businesses** (`place`)
- **$0.50 per 1,000 search queries** (`query`)
- **$1.00 per 1,000 phone enrichments** (`detail-enrich`, only when `enrichDetail` is on)

Empty searches are never billed. [View current pricing.](https://apify.com/foxlabs/naver-place-scraper)

### ❓ FAQ

**Do I need a Naver account, login or API key?** No. The actor reads Naver Place's own public, server-rendered page data.

**How many businesses do I get per query?** Naver Place shows roughly 50–60 top results per query, and that is what a single query returns. For wider coverage, run several district-level queries rather than one broad one.

**Why is the phone empty for some businesses?** A few verticals (notably hair salons) don't show a phone in the list. Turn on `enrichDetail` and the actor fetches each business's detail page to recover it (business hours may still be unavailable for those verticals).

**What language are the queries and data in?** Queries and most fields are Korean. Send the input as UTF-8 so the Korean text is preserved.

**Does it cover the whole country?** Any region Naver Place indexes — write the region into the query (`부산 병원`, `제주 카페`).

**Can I export to CSV / Excel / JSON?** Yes — directly from the Apify dataset.

**What happens when a search finds nothing?** The run succeeds with no rows for that query and you are not charged for it.

**Is scraping this legal?** It reads public business-profile data that Naver Place publishes for discovery. It contains business data, not personal user data. See below.

### 🐛 Troubleshooting

- **The query came back as `?? ??` / zero results** — the Korean text was not sent as UTF-8. Use a UTF-8 body (`--data-binary`, or the Apify console/UI which handles it).
- **Phone missing for a vertical** — turn on `enrichDetail` (hair salons and some verticals hide it in the list).
- **Fewer rows than a city has** — this is expected; Naver shows ~50–60 per query. Split into district-level queries.

### ⚠️ Trademark

Independent, third-party tool. Not affiliated with, endorsed by or connected to NAVER Corp. "Naver", "Naver Place" (네이버 플레이스) and related marks belong to their owners and are used here for identification only.

### ⚖️ Is it legal to scrape this data?

This actor reads only publicly published business-profile data (name, category, address, phone, hours, ratings) — not private or personal user data. Results can still contain personal data in edge cases (e.g. a person's name used as a business name); personal data is protected by Korea's PIPA, the GDPR and similar laws, so only process it with a legitimate basis. See Apify's blog post on the legality of web scraping.

### 🤝 Support & contact

- 🌐 **Website:** [data.foxlabs.com.tr](https://data.foxlabs.com.tr)
- 📧 **Email:** info@foxlabs.com.tr
- 🐛 **Issues:** open a ticket in the Actor's **Issues** tab
- 🧰 **More clean B2B data actors:** [Fox Labs on Apify](https://apify.com/foxlabs)

### Changelog

#### 0.1 — 2026-10-21

- Initial release: Korean local-business search on Naver Place by keyword + region. Returns name, category, phone, address, hours, coordinates, review counts/score, booking/N-Pay flags, booking URL, image and place URL. `enrichDetail` recovers the phone for sparse verticals. Reads server-rendered page state (no token); runs a browser through Apify datacenter proxy. Pay-per-event: delivered business + search query + phone enrichment.

# Changelog

This Actor's version history is a separate document: https://apify.com/foxlabs/naver-place-scraper/changelog.md

# Actor input Schema

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

Korean search phrases with region + category, e.g. "강남 카페" (Gangnam cafes), "부산 병원" (Busan hospitals), "강남 미용실" (Gangnam hair salons).

## `maxRecordsPerQuery` (type: `integer`):

Cap on businesses returned per query.

## `enrichDetail` (type: `boolean`):

For sparse verticals (e.g. hair salons) the phone is missing in the list; fetch each business's detail page to recover it. Adds one request per enriched business.

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

Naver throttles non-browser and repeat requests; proxy rotation is recommended. Apify datacenter proxy is enough.

## Actor input object example

```json
{
  "queries": [
    "강남 카페",
    "부산 병원"
  ],
  "maxRecordsPerQuery": 100,
  "enrichDetail": false,
  "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 = {
    "queries": [
        "강남 카페"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/naver-place-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": ["강남 카페"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/naver-place-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 '{
  "queries": [
    "강남 카페"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call foxlabs/naver-place-scraper --silent --output-dataset

```

## MCP server setup

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