# Naver Place Search Scraper (네이버 플레이스 검색) (`romantic_boysenberry/naver-place-search-scraper`) Actor

Search Naver Place / Naver Map by keyword. Get business IDs, names, categories, road addresses, visitor review counts and place URLs. No Naver login or API key.

- **URL**: https://apify.com/romantic_boysenberry/naver-place-search-scraper.md
- **Developed by:** [정무 최](https://apify.com/romantic_boysenberry) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 results

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 Search Scraper (네이버 플레이스 검색)

**Naver Place Search Scraper** searches **Naver Place** and **Naver Map (네이버 지도)** by keyword and returns structured Korean business listings. Enter a district and business category such as `강남 카페`, `홍대 맛집`, or `부산 치과` to collect place IDs, business names, categories, road addresses, visitor review counts, and links to the original listings. Export your results as JSON, CSV, or Excel for local market research, business discovery, and Korean local SEO workflows.

No Naver account or Naver API key is required. The Actor reads publicly accessible search results through HTTP requests and writes one dataset item per unique business. Pricing is **$0.002 per returned place**, equivalent to **$2.00 per 1,000 results**. Search overlapping keywords in the same run and matching place IDs are deduplicated before output.

### What does Naver Place Search Scraper do?

This Naver Map scraper turns a list of search phrases into a downloadable business dataset. It requests the server-rendered Naver Place results page for each phrase, extracts the listing fields available on that page, and adds a direct Naver Place URL. Results are fetched from Naver during each run rather than supplied from a stored directory.

Use Korean search phrases that combine a neighborhood, city, or district with a business type. Searches can discover restaurants and cafes, dental clinics and hospitals, hair salons and gyms, hotels and guesthouses, academies, pet shops, and other businesses that appear in Naver Place results. Available listings depend on what Naver returns for your query and network location.

The Actor collects the **first search results page only**. It does not paginate across all Naver Map results, fetch complete business profiles, or retrieve individual reviews. This makes it useful for targeted business discovery and a practical starting point for a separate review collection workflow. For review text, use the related Naver Place Reviews Scraper linked below.

### Why use this Naver Place search scraper?

- **Structured Korean business data.** Get consistent field names instead of manually copying names and addresses from map pages. The output can go directly into spreadsheets, databases, or analysis notebooks.
- **Simple keyword input.** Start with familiar Naver Map queries. No place ID lookup or developer application registration is necessary for searching.
- **Deduplicated results within a run.** If two keywords discover the same place ID, that business appears once in the dataset. This also keeps the result count aligned with the unique places returned.
- **Transparent result pricing.** The Actor price is $0.002 per dataset item. Set a small per-keyword limit to evaluate the output before collecting a larger batch.
- **HTTP collection.** The implementation does not launch a headless browser, reducing the machinery required to search and parse public listing pages.
- **Apify automation.** Run from the Console, an API client, a schedule, or an integration. The dataset remains accessible through standard Apify export tools.

Naver can block requests or return a CAPTCHA, particularly from datacenter IP ranges. Korean residential proxies are recommended; they improve the network setup but do not guarantee every keyword will succeed.

### Output: what data can you extract from Naver Place search?

Each dataset item represents one business found in the search results. The Actor returns exactly these six fields:

| Field | Example | Description |
|---|---|---|
| `id` | `2093423408` | Naver Place business ID, returned as a string. Use this identifier to join datasets or deduplicate across runs. |
| `name` | `CAFE 00:00` | Business name as supplied by Naver's search results. |
| `category` | `카페,디저트` | Listing category, or `null` when unavailable. |
| `roadAddress` | `서울 강남구 학동로46길 27 1층` | Road address in the search results, or `null` when unavailable. |
| `visitorReviewCount` | `120` | Visitor review count as supplied by Naver. The source representation is preserved; unavailable values are `null`. |
| `placeUrl` | `https://m.place.naver.com/place/2093423408/home` | Direct link constructed from the place ID. |

An illustrative dataset item looks like this:

```json
{
  "id": "2093423408",
  "name": "CAFE 00:00",
  "category": "카페,디저트",
  "roadAddress": "서울 강남구 학동로46길 27 1층",
  "visitorReviewCount": "120",
  "placeUrl": "https://m.place.naver.com/place/2093423408/home"
}
```

The example illustrates the schema rather than guaranteeing current details for that business. There are no telephone numbers, coordinates, opening hours, review bodies, ratings, or search keyword fields in this output. If your downstream system needs numeric review counts, inspect and normalize the source values before doing arithmetic.

Download the dataset from the Apify Console as JSON, CSV, Excel, or another supported export format. Preserve the `id` column as text in spreadsheets so identifiers remain unchanged. Across repeated runs, deduplicate by `id`; the Actor only removes duplicates within the current run.

### How to scrape Naver Place search results

1. Open **Naver Place Search Scraper** in Apify Store and select **Try for free** or open its input form.
2. Enter one or more search keywords. Start with a specific phrase such as `성수 카페` or `분당 피부과`.
3. Set **Max places per keyword**. The default is 10; use a smaller number for an initial sample.
4. Keep the recommended Apify residential proxy configuration with country **KR** when running on Apify.
5. Click **Start**, then inspect the run log and **Output** tab. Download the returned business listings or retrieve the dataset through the API.

Check several sample rows before building a recurring workflow. Naver chooses which businesses to show for each phrase, so a broad query is not a complete directory of a city. Narrower location and category combinations usually make the returned listings easier to interpret.

### Input parameters

| Parameter | Type | Default or form prefill | Description |
|---|---|---|---|
| `keywords` | array of strings | Form prefill: `["강남 카페"]` | Required. At least one non-empty Naver Map search phrase. API callers must provide this array. |
| `maxPlacesPerKeyword` | integer | `10` | Maximum places taken from each keyword's first results page. Valid range: 1 to 100. Applied before deduplication. |
| `proxyConfiguration` | object | Form prefill: Apify residential proxy, KR | Optional proxy setup. Korean residential proxies are recommended for cloud runs. API callers should pass it explicitly to use that setup. |

Example input:

```json
{
  "keywords": ["강남 카페", "홍대 맛집"],
  "maxPlacesPerKeyword": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "KR"
  }
}
```

The per-keyword limit is an upper bound, not a promised number of results. If the first page has eight places and your limit is 20, only those eight are available. If overlapping keywords each return ten places, the final dataset can contain fewer than twenty unique businesses. Raising the limit to 100 does not enable pagination.

Invalid keywords or an out-of-range limit cause the Actor to fail with an input error. Individual search failures are logged and remaining keywords are attempted. If at least one unique place is collected, the Actor can succeed with partial results; review the logs when completeness matters. If no places are collected, the Actor fails instead of reporting a successful empty dataset.

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

Naver Place Search Scraper uses **pay-per-event pricing** with a single result event, `apify-default-dataset-item`. The Actor price is **$0.002 for each place written to the dataset**. It does not add custom startup, keyword, or review events. Duplicates removed within a run do not create extra dataset items.

| Unique places returned | Actor result price |
|---|---|
| 1 | $0.002 |
| 100 | $0.20 |
| 1,000 | $2.00 |
| 10,000 | $20.00 |
| 100,000 | $200.00 |

These are result-price examples, not promises that a single run or keyword can return these volumes. First-page coverage and overlap affect the total. For example, five keywords with a limit of ten can produce at most fifty unique places, making the Actor result charge at most $0.10 for that batch if all fifty are returned.

The **Pay per event + usage** option is disabled for this Actor. The table describes the Actor's result charge; consult Apify's current pricing and your account billing for any applicable proxy, storage, export, or other platform charges. Do not assume an empty or failed run makes all platform services free. Check the run's usage details when estimating a recurring collection budget.

### Use cases for Naver Place business data

- **Local market research.** Build a shortlist of cafes, clinics, hotels, or other businesses in a neighborhood. Compare category and address information without maintaining a manually copied map list.
- **Korean local SEO and 플레이스 마케팅.** Discover businesses appearing for a client-relevant query and record listing information over time. The results reflect the fetched search page and should not be treated as a universal ranking measurement.
- **Site selection.** Gather nearby competitors for several candidate districts. Combine these listings with your own footfall, rent, and demographic data; the Actor does not provide those additional measures.
- **Franchise and agency research.** Search for a brand and location, then use place IDs to organize a set of listings for further analysis. Verify matches because similar names can refer to unrelated businesses.
- **Review research preparation.** Identify places first, then pass their IDs to the separate reviews Actor to collect visitor review text. The search output's review count helps prioritize which listings to inspect.
- **Spreadsheet and database workflows.** Import the six-field output into an existing dataset, keeping the place ID as a join key. Store a collection date in your own workflow if you need historical snapshots.

Use the original `placeUrl` to check a listing before making business decisions. A search result is a discovery record, and an address or review count can change after collection.

### Use Naver Place Search Scraper from code

The examples below use the published Actor name `romantic_boysenberry/naver-place-search-scraper`. The Actor ID is `ETywTbrzOrHqG0zzi`. You need an **Apify API token**, not a Naver API key. Keep the token in an environment variable and install the corresponding Apify client package for Python or JavaScript.

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("romantic_boysenberry/naver-place-search-scraper").call(
    run_input={
        "keywords": ["강남 카페", "성수 카페"],
        "maxPlacesPerKeyword": 10,
        "proxyConfiguration": {
            "useApifyProxy": True,
            "apifyProxyGroups": ["RESIDENTIAL"],
            "apifyProxyCountry": "KR",
        },
    }
)
if run is None or run["status"] != "SUCCEEDED":
    raise RuntimeError("Actor did not succeed; inspect its run log.")
for place in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(place["id"], place["name"], place["roadAddress"])
```

Dataset iteration is useful when retrieving more items than fit in a single API response. Add your own destination logic if you want to write each item into a spreadsheet, warehouse, or local file.

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('romantic_boysenberry/naver-place-search-scraper').call({
  keywords: ['홍대 맛집'],
  maxPlacesPerKeyword: 10,
  proxyConfiguration: {
    useApifyProxy: true,
    apifyProxyGroups: ['RESIDENTIAL'],
    apifyProxyCountry: 'KR',
  },
});
if (!run || run.status !== 'SUCCEEDED') {
  throw new Error('Actor did not succeed; inspect its run log.');
}
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map(({ id, name, placeUrl }) => ({ id, name, placeUrl })));
```

For a larger multi-keyword run, paginate dataset API requests rather than assuming `listItems()` returns every record. Save the run ID and dataset ID when connecting the output to another service.

#### cURL

```bash
curl --fail-with-body --request POST \
  'https://api.apify.com/v2/acts/romantic_boysenberry~naver-place-search-scraper/run-sync-get-dataset-items' \
  --header "Authorization: Bearer $APIFY_TOKEN" \
  --header 'Content-Type: application/json' \
  --data '{"keywords":["부산 치과"],"maxPlacesPerKeyword":5,"proxyConfiguration":{"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"],"apifyProxyCountry":"KR"}}'
```

The synchronous endpoint is convenient for a small test. For longer jobs, start an asynchronous run, wait for completion, and fetch its default dataset. Inspect unsuccessful API responses and run logs instead of treating a missing dataset as proof that no matching businesses exist.

### Integrations and scheduled collection

Apify Schedules can repeat a saved input daily or weekly. Standard Apify integrations let tools such as n8n, Make, or Zapier start runs and handle the output. An Apify-compatible agent or MCP workflow can invoke the Actor with the same input fields used by the Console.

Schedule only the queries you need and track the returned place IDs in your destination. Because each run fetches live results, a business may appear or disappear between snapshots. To follow specific businesses' reviews, use their IDs with the reviews Actor; this search Actor accepts keywords rather than a direct list of place IDs.

### Tips for best results

Use Korean business categories and recognizable location names, such as `판교 헬스장`, `광안리 횟집`, or `제주 호텔`. A broad phrase like `카페` offers less geographic control than a neighborhood plus category. Split a large area into narrower queries while remembering that overlapping results are deduplicated only within each run.

Start with ten places per keyword and inspect the fields that matter to your task. Keep Korean residential proxies configured on Apify, especially if previous runs from datacenter IPs encountered CAPTCHA pages. Increasing the result limit will not fix a blocked request or reveal additional pages.

Check both dataset contents and warnings in the run log. A successful run with fewer businesses than expected may reflect deduplication, a small first page, or failed keywords. Keep separate collection timestamps and input records in your own workflow when comparing runs over time.

### Limitations

- Only the first server-rendered search page is collected, typically around 20 to 50 listings depending on the query. There is no exhaustive city-wide coverage or pagination.
- Only six listing fields are returned. Full business details, contact information, coordinates, review text, and photos are outside this Actor's scope.
- Naver may serve CAPTCHA or change its page markup. Korean residential proxies are recommended, but uninterrupted collection is not guaranteed.
- Missing category, road address, or visitor review count is represented by `null`. Review counts retain the source representation.
- Results are deduplicated by place ID within one run. Deduplication and historical tracking across runs belong in your downstream workflow.
- Individual keyword errors can produce a partial successful dataset. A run with no collected places fails; consult the logs to distinguish network problems from query issues.

### Legal and responsible use

The Actor collects publicly visible business listing fields without logging into Naver. Use the output for legitimate research and analysis in accordance with applicable law and the source website's terms. The Actor does not collect private account information or private contact details. Verify source listings and handle the exported data appropriately for your intended use.

### FAQ

#### 1. Do I need a Naver API key or Naver account?

No. The Actor requests public Naver Place search pages without Naver login or a Naver Developers key. Running through Apify's API requires an Apify token for your own account. This Actor is separate from the official Naver local search API and returns the six fields documented above.

#### 2. Can it collect every business in a district?

No. It collects the first search results page for each keyword, with your per-keyword limit applied to that page. Even a limit of 100 does not activate pagination. Use narrower district and category combinations for targeted discovery, and expect overlap rather than treating the results as a complete business census.

#### 3. Does it scrape visitor reviews, ratings, or business phone numbers?

It returns the visitor review count available in search results, but no individual reviews, ratings, or phone numbers. Use [Naver Place Reviews Scraper](https://apify.com/romantic_boysenberry/naver-place-reviews-scraper) for visitor review content. You can pass the discovered `id` values to that Actor's `placeIds` input.

#### 4. Why did a search fail or return fewer places than expected?

Naver may block the request, return a CAPTCHA, change its markup, or provide fewer listings on the first page. Overlapping keywords also reduce the unique output count. Check the log, verify the search terms, and use Korean residential proxies on Apify. The Actor fails when no places are collected and logs individual keyword errors when other searches can continue.

#### 5. How are duplicates and charges handled?

Within one run, matching place IDs are written once even when several keywords discover them. Each returned dataset item uses the single `apify-default-dataset-item` event at $0.002 per place. New runs have their own datasets and can return the same business again. The Pay per event + usage option is disabled; check your Apify billing for any other applicable services.

### Related Actors

- [Naver Place Reviews Scraper](https://apify.com/romantic_boysenberry/naver-place-reviews-scraper): collect visitor review content for businesses discovered by this search Actor. Use its `placeIds` input to target the IDs in this dataset.
- [More Actors by romantic_boysenberry](https://apify.com/romantic_boysenberry): browse other available data collection tools from this developer.

***

### 네이버 플레이스 검색 수집기 (한국어 요약)

**네이버 플레이스 검색 수집기**는 `강남 카페`, `홍대 맛집`, `부산 치과` 같은 검색어로 네이버 지도·플레이스의 공개 업체 목록을 수집하는 Apify 액터입니다. 네이버 로그인이나 네이버 API 키 없이 실행하며 결과를 JSON, CSV, Excel로 내려받을 수 있습니다.

- 출력 필드: `id`(플레이스 ID), `name`(상호), `category`(업종), `roadAddress`(도로명 주소), `visitorReviewCount`(방문자 리뷰 수), `placeUrl`(플레이스 링크).
- 가격: 결과 1건당 **$0.002**, 1,000건당 **$2.00**. 과금 이벤트는 `apify-default-dataset-item` 하나이며 Pay per event + usage 옵션은 꺼져 있습니다. 별도 서비스 비용은 Apify 계정의 요금 정보를 확인하세요.
- 입력: 검색어 배열 `keywords`는 필수입니다. `maxPlacesPerKeyword`는 기본 10, 허용 범위 1~100이며 검색어별 첫 페이지에서 가져올 최대 업체 수입니다.
- 수집 범위: **첫 검색 결과 페이지만** 수집합니다. 100을 입력해도 다음 페이지를 수집하지 않으며 전체 상권의 모든 업체를 보장하지 않습니다.
- 중복 처리: 한 실행에서 같은 플레이스 ID는 한 번만 출력합니다. 서로 다른 실행 사이의 중복은 직접 처리해야 합니다.
- 프록시: Apify에서는 한국(KR) 주거용 프록시를 권장합니다. API 호출에서는 예제처럼 프록시 설정을 직접 전달하세요. 데이터센터 IP는 캡차나 차단으로 실패할 수 있습니다.
- 오류 처리: 일부 검색어가 실패해도 다른 검색어의 결과가 있으면 실행이 성공할 수 있으므로 로그를 확인하세요. 수집된 업체가 하나도 없으면 실행은 실패합니다.

사용법: 액터 페이지에서 입력 폼 열기 → 검색어 입력 → 최대 업체 수와 KR 주거용 프록시 확인 → **Start** → **Output**에서 결과 확인·다운로드. 상권 조사, 경쟁 업체 탐색, 플레이스 마케팅 자료 정리, 리뷰 분석 대상 선정에 활용할 수 있습니다.

리뷰 본문이 필요하면 결과의 `id`를 [네이버 플레이스 리뷰 수집기](https://apify.com/romantic_boysenberry/naver-place-reviews-scraper)의 `placeIds`에 전달하세요. 검색 액터 자체는 리뷰 본문·별점·전화번호·사진을 수집하지 않습니다. 공개 업체 데이터는 관련 법령과 네이버 약관에 맞게 사용하세요.

# Actor input Schema

## `keywords` (type: `array`):

Naver Map search queries, e.g. 강남 카페 or 홍대 맛집. Provide at least one non-empty keyword.

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

Maximum places taken from each keyword's first results page. Actual results may be fewer; overlapping places are returned once.

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

Apify residential proxy in Korea is recommended because Naver may block datacenter IPs.

## Actor input object example

```json
{
  "keywords": [
    "강남 카페"
  ],
  "maxPlacesPerKeyword": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "KR"
  }
}
```

# Actor output Schema

## `places` (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 = {
    "keywords": [
        "강남 카페"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "KR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("romantic_boysenberry/naver-place-search-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 = {
    "keywords": ["강남 카페"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "KR",
    },
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,romantic_boysenberry/naver-place-search-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/ETywTbrzOrHqG0zzi/builds/526CqhCZ7vtUPsAbS/openapi.json