# Naver Map Places (Enhanced): Korean Business Data API (`clover_engineer/naver-map-places-enhanced`) Actor

Korean business data from Naver Map: ratings, review counts, hours, menus, GPS. 300+ places per search, area sweeps, English output. No API key.

- **URL**: https://apify.com/clover\_engineer/naver-map-places-enhanced.md
- **Developed by:** [Clover](https://apify.com/clover_engineer) (community)
- **Categories:** Lead generation, Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 places

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/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 Map Places (Enhanced): Korean Business Data API

Get **Naver Map (네이버 지도) / Naver Place** business data as clean, typed JSON: restaurants, cafes, hotels, clinics, pharmacies, gyms, salons, shops, any local business in South Korea. **No API key needed.**

Naver Map is the map Koreans actually use, and Google Maps covers Korean businesses poorly. If your product, research or sales pipeline needs Korean local data, this is the source.

It goes well beyond **Naver's official Search API**, which Naver limits to 5 places per search with no ratings or place IDs. See the comparison below.

### This actor vs Naver's official Search API

| | **This actor** | **Naver's official Search API** |
|---|---|---|
| Data source | Naver Place, as used by the Naver Map website | Naver's official **Search API** (developers.naver.com) |
| Places per search | **Up to 300**, and **thousands** with a map-area sweep | **5** (Naver's hard limit for its official local search) |
| Place ID and Naver Map link | ✅ | ❌ (the official API doesn't return them) |
| Visitor rating, visitor and blog review counts | ✅ | ❌ |
| Open/closed status, amenities, booking and Naver Pay flags, image | ✅ | ❌ |
| Opening hours per day, menu with prices, subway exit, review themes | ✅ with `includeDetails` | ❌ |
| English output (Naver's own translation) | ✅ `language: "en"` | ❌ Korean only |
| Distance sort, map-area search, look up by place ID or link | ✅ | ❌ |
| Name, category, address, business phone, GPS coordinates | ✅ | ✅ |
| API key | Not needed | A Naver developer key (Client ID + Secret) |

**When is the official API enough?**

- **Use this actor** if you need more than a handful of places, ratings or review counts, IDs to track places over time, or English data. That's almost every use case.
- **The official API** can be enough if your compliance team requires data obtained only through Naver's official API, and 5 places per search with name, category, address, phone and coordinates covers your need.

### Why teams choose this actor

**It returns what you asked for.** In our reliability test we searched 12 place categories across 8 Korean cities (restaurants, cafes, hotels, a Jeju speciality, hair salons, hospitals, pharmacies, gyms, pop-up stores, currency exchange, nail salons) and got:

- 20 places each, 240 in total, all unique, in 10 seconds
- **0 schema errors**
- coordinates, category and street address on **100%** of places

On Apify's servers we tested 8 more scenarios (Korean and English output, details, place ID lookup, distance sort, area sweep). **8 of 8 succeeded, with no rate limiting or blocking.**

**It goes past Naver's 300-place cap.** Naver stops every search at 300 results. Give a map rectangle and the actor splits it into smaller cells until each holds fewer than 300 places. In our test, "카페" over Hongdae/Mapo returned **2,463 of the 2,464** places Naver reported for the area, all inside the box.

**It fails loudly, never silently.**

- Wrong input (coordinates outside Korea, a missing search center for distance sort) stops the run within seconds, with a message that says exactly what to fix.
- You're **never charged for a failed place or search**.
- If your run's spending limit is reached, the actor stops cleanly and tells you how far it got.

**It's typed and consistent.** Counts are integers, ratings and coordinates are numbers, flags are booleans. Field names are English; Korean text values are kept as they are. Every row has the same fields, so downstream code never breaks on a missing key.

**It respects privacy.** Only public business listing data is collected. Private mobile numbers that some sole traders display (010-…) are **removed**; only business lines and Naver's 0507 smart-call numbers are kept. In our 240-place test, 0 private mobiles reached the output. No review texts or reviewer identities are collected.

### Use cases

- **Market sizing and competitor mapping.** How many cafes are in Seongsu, how are they rated, and which are new?
- **Location intelligence.** Coordinates and categories for GIS, footfall and site-selection models.
- **B2B lead lists.** Korean businesses by area and category, business phone numbers only.
- **Travel, food and expat apps.** Places with English names, ratings, hours and menus.
- **Monitoring.** Schedule the actor and track ratings, review counts and open status by place ID.
- **AI agents.** One call answers "find the top-rated ramen places near Gangnam station" with structured data.

### Input

| Field | Default | Description |
|---|---|---|
| `searchQueries` | – | What you'd type into Naver Map: `강남역 맛집`, `홍대 카페`, `부산 해운대 호텔`. Korean matches far more places. |
| `placeIds` | – | Numeric IDs (`1793702349`) or `map.naver.com` / `place.naver.com` / `naver.me` links. |
| `maxResultsPerQuery` | 50 | Places per search (Naver caps one search at 300; use `searchArea` for more). |
| `language` | `ko` | `en` returns Naver's English names, categories, addresses and status. |
| `includeDetails` | false | Adds `details`: hours per day, menu, description, links, keywords, payment methods, nearest subway, review themes. |
| `center` | – | `"latitude,longitude"`; adds `distance` to each place. |
| `sortBy` | `relevance` | `distance` = nearest to `center` first. |
| `searchArea` | – | Map rectangle `"minLng,minLat,maxLng,maxLat"`; sweeps beyond 300 places. |
| `deduplicate`, `requestDelayMs`, `maxRetries`, `proxyConfiguration` | | Run control. No proxy needed in our tests. |

**Example:**

```json
{ "searchQueries": ["홍대 카페", "부산 해운대 호텔"], "maxResultsPerQuery": 60, "language": "en", "includeDetails": true }
```

### Output

One item per place. A real item from the default input (`강남역 맛집`):

```json
{
  "placeId": "1793702349",
  "name": "플랫나인",
  "category": "요리주점",
  "address": "서울특별시 서초구 서초동 1308-15 5층",
  "roadAddress": "강남대로65길 10 5층",
  "district": "서울 서초구 서초동",
  "phone": "0507-1389-9630",
  "latitude": 37.5005009,
  "longitude": 127.0249641,
  "rating": 4.84,
  "visitorReviewCount": 4364,
  "blogReviewCount": 3306,
  "saveCount": "111,000+",
  "tagline": "음식과 음악이 만나는 완벽한 조화",
  "amenities": ["단체 이용 가능", "예약", "무선 인터넷"],
  "businessStatus": "오늘 휴무",
  "hasNaverBooking": true,
  "acceptsNaverPay": true,
  "wheelchairAccessible": true,
  "imageUrl": "https://ldb-phinf.pstatic.net/…/DSC_0519-93.jpg",
  "placeUrl": "https://map.naver.com/p/entry/place/1793702349",
  "searchQuery": "강남역 맛집",
  "rank": 1,
  "language": "ko",
  "scrapedAt": "2026-09-24T18:37:16.674Z"
}
```

- With `language: "en"`: `"name": "FLATNINE"`, `"category": "Pub"`, `"address": "1308-15 Seocho-dong Seocho-gu Seoul"`.
- With `includeDetails: true`, each item also gets a `details` object:
  - `openingHours`: per day, with breaks and last order
  - `menu`: name, price, representative flag
  - `nearestSubway`: station, line, exit, walking minutes and metres
  - plus `description`, `links`, `keywords`, `paymentMethods`, `reviewThemes` and `photoCount`

The dataset has two views: **Overview** ( name, category, rating, reviews, phone, address, link) and **Locations** (coordinates).

### Pricing

Pay per result. You're never charged for the actor start, and never for failed places or searches.

| Apify subscription | Per place | Per 1,000 places |
|---|---|---|
| Free | $0.0030 | $3.00 |
| Bronze | $0.0027 | $2.70 |
| Silver | $0.0024 | $2.40 |
| Gold and above | $0.0021 | $2.10 |

**Details are included in the price.** Other actors charge extra per detail page or add a start fee.

**Examples (Free plan):**

- 100 restaurants with hours and menus: $0.30
- A full district sweep of about 2,500 cafes: about $7.50

### Limits and notes

- **Naver's official Search API** is limited by Naver to 5 places per search, with no paging and no place IDs. This actor doesn't have that limit.
- **This actor:**
  - It reads Naver Place's public web endpoints, which Naver can change without notice. The actor retries with backoff and reports clearly if Naver blocks it; a proxy can be enabled.
  - 300 places per search is Naver's cap; use `searchArea` or narrower queries to get more.
- `rating` is `null` when Naver shows no score. In our 240-place test that was 61% of places, typical for cafes, clinics and new places. Review counts are still given: 91% had visitor reviews.
- `details` come from the place page, which Naver serves in Korean only, even with `language: "en"`.
- Detail pages are rate-limited more strictly than search. For very large detail runs, keep the default delay.
- Use of the data must comply with Naver's terms and applicable law (e.g. Korea's PIPA).

### FAQ

**Is this allowed?** It reads publicly visible business listings the way the Naver Map website does, without logging in and without collecting personal data. If your organisation requires officially licensed access only, use Naver's official Search API with your own developer key (limited by Naver to 5 places per search).

**Do I need an API key?** No. No Naver account or key is needed.

**How is this different from Naver's official Search API?** The official local search API returns at most 5 places per search, with name, category, address, phone and coordinates only. This actor returns up to 300 per search (more with `searchArea`), with IDs, ratings, review counts, status, English output and optional hours and menus.

**Can I search in English?** Yes, but Korean queries match far more places: Naver reported 78 matches for "Gangnam cafe" and 2,530 for "홍대 카페". Use `language: "en"` to get English output.

**How do I get `searchArea` coordinates?** Take the south-west corner (min longitude, min latitude) and the north-east corner (max longitude, max latitude); longitude comes first. Seoul is roughly longitude 126.8–127.2, latitude 37.4–37.7.

**Does it collect review texts?** No, only ratings, counts and review-theme counts.

**Why fewer places than `maxResultsPerQuery`?** Naver had fewer matches, the 300 cap applied (use `searchArea`), or `deduplicate` skipped places already returned.

# Actor input Schema

## `searchQueries` (type: `array`):

What you would type into Naver Map, e.g. "강남역 맛집" (Gangnam station restaurants), "홍대 카페", "부산 해운대 호텔". Korean queries return the most places; English queries work too.

## `placeIds` (type: `array`):

Specific places to fetch: a numeric Naver place ID (e.g. 1793702349) or a map.naver.com / place.naver.com / naver.me link.

## `maxResultsPerQuery` (type: `integer`):

Stop each query after this many places. Naver returns at most 300 places per search; set "Search area" to sweep the map and go beyond 300.

## `language` (type: `string`):

"en" returns Naver's own English names, categories, addresses and opening status (e.g. "FLATNINE", "Pub", "Seocho-gu Seoul"). Some free-text fields (amenities, tagline) stay Korean.

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

Visit each place page to add opening hours per day, menu with prices, description, homepage/social links, keywords, payment methods, nearest subway exit and review themes. One extra request per place (slower); same price.

## `center` (type: `string`):

"latitude,longitude" the search is relative to, e.g. "37.4979,127.0276". Adds a distance to each place. Needed for sorting by distance.

## `sortBy` (type: `string`):

Naver's relevance ranking, or nearest to "Search center" first.

## `searchArea` (type: `string`):

Limit results to a map rectangle "minLng,minLat,maxLng,maxLat", e.g. "126.90,37.54,126.94,37.57" (Hongdae/Mapo). Cells with more than 300 places are split automatically, so a whole district can be collected beyond Naver's 300-per-search limit.

## `deduplicate` (type: `boolean`):

Output each place only once per run, even if several queries or map cells find it (you are only charged once).

## `requestDelayMs` (type: `integer`):

Minimum pause between requests to Naver. Lower is faster; raise it if you see 429 errors.

## `maxRetries` (type: `integer`):

Retries per request on errors or rate limits, with backoff (and a new proxy IP when a proxy is set).

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

Optional. Off by default (Naver Place answered without a proxy in tests); enable if you get blocked.

## Actor input object example

```json
{
  "searchQueries": [
    "강남역 맛집"
  ],
  "maxResultsPerQuery": 20,
  "language": "ko",
  "includeDetails": false,
  "sortBy": "relevance",
  "deduplicate": true,
  "requestDelayMs": 500,
  "maxRetries": 3
}
```

# Actor output Schema

## `results` (type: `string`):

All places as JSON, one item per place.

## `overview` (type: `string`):

One row per place: name, category, rating, reviews, phone, address.

# 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 = {
    "searchQueries": [
        "강남역 맛집"
    ],
    "maxResultsPerQuery": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("clover_engineer/naver-map-places-enhanced").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 = {
    "searchQueries": ["강남역 맛집"],
    "maxResultsPerQuery": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("clover_engineer/naver-map-places-enhanced").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 '{
  "searchQueries": [
    "강남역 맛집"
  ],
  "maxResultsPerQuery": 20
}' |
apify call clover_engineer/naver-map-places-enhanced --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,clover_engineer/naver-map-places-enhanced"
        }
    }
}
```

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/0ujmfhqNjiBAj22ZQ/builds/gsQTIh38iiXGSzpiT/openapi.json