# Naver Map Scraper - Korean Places, Reviews, Phone, GPS (`s-r/naver-map-scraper`) Actor

Scrape Naver Map search results for South Korea and get business name, category, road address, phone, review score, review counts, opening hours and GPS coordinates as clean rows. Covers restaurants, cafes, clinics, hotels and attractions.

- **URL**: https://apify.com/s-r/naver-map-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** Travel, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 actor run starteds

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 Map Scraper - Korean places, reviews, phone numbers and GPS

Scrape Naver Map search results for South Korea and get the business name,
category, road address, phone number, visitor review score, review counts
and GPS coordinates as clean rows. This Naver Map scraper reads the same place
list Korean users see, which is the only complete local business directory for
the country, because Google Maps does not have one.

### What you get

- 50 places per page, paged automatically until your row limit
- Naver place id and a direct link to the place page on Naver Map
- Business name, category line and Naver's numeric category codes, which survive
  a category being renamed
- Road-name address, lot-number address and the city / ward / neighbourhood line,
  so you can group results by area without parsing strings
- Public phone number, falling back to Naver's forwarding number when that is all
  the business publishes
- Visitor review score out of 5, visitor review count, blog and cafe review count
  and the combined total
- Opening hours line, owner blurb and the short quoted highlights Naver shows on
  the card
- Latitude and longitude on every row, already the right way round
- Naver Booking and Naver Pay flags, a newly-opened flag, and the service tags
  Naver lists such as parking or takeaway
- A run summary that separates "this search found nothing" from "the site did not
  serve us", because in a dataset those two look identical and mean completely
  different things

### Why scrape Naver Map

South Korea is the one large market where Google Maps is not the local business
directory. Korean export restrictions on mapping data mean Google ships a
degraded product there, so Koreans search for restaurants, clinics, salons and
hotels on Naver Map instead. If you want Korean local business data, Naver is
not one source among several, it is the source.

The Naver Local Search open API exists but returns five results per call with a
handful of fields and no review data at all, which is not enough to build
anything on. The place list behind Naver Map carries the review scores, the
review counts, the coordinates and the booking flags, and
those are exactly the fields that make local business data worth collecting.

Review counts are the part people underestimate. Naver splits them in two:
visitor reviews written by people who were there, and blog and cafe posts that
Naver has linked to the business. Those two numbers move for different reasons.
Visitor reviews track actual footfall; blog counts track marketing spend, because
sponsored blog posting is a normal part of Korean local marketing. Having both on
the same row is how you tell a busy restaurant from a well-promoted one.

### Input

| Field | Type | Required | What it does |
|---|---|---|---|
| `query` | string | yes | What to search for, for example `강남 카페` or `서울 치과` |
| `businessType` | select | no | Which Naver list to search: all places, restaurants, clinics, stays or attractions |
| `latitude` | string | no | Centre the search on a point, pair with longitude |
| `longitude` | string | no | Centre the search on a point, pair with latitude |
| `maxItems` | integer | no | Stop after this many places, default 50 |

Korean queries give the fullest results, which is a property of the index rather
than of this actor: Naver files businesses under Korean names, so a Korean query
matches more of them. Latin-script brand names work where the business itself
uses one.

### Output

```json
{
  "place_id": "1668757640",
  "name": "퍼스트커피랩 강남점",
  "category": "카페,디저트",
  "category_codes": ["220036", "220052", "220563"],
  "business_type": "restaurant",
  "url": "https://map.naver.com/p/entry/place/1668757640",
  "road_address": "봉은사로6길 39 1층",
  "address": "서울특별시 강남구 역삼동 …",
  "district": "서울 강남구 역삼동",
  "phone": "0507-1315-7680",
  "visitor_review_score": 4.91,
  "visitor_review_count": 3177,
  "blog_review_count": 2078,
  "total_review_count": 5255,
  "description": null,
  "micro_review": [],
  "image_url": "https://ldb-phinf.pstatic.net/…",
  "image_count": 12,
  "has_booking": true,
  "has_npay": false,
  "is_new": false,
  "options": [],
  "latitude": 37.5026235,
  "longitude": 127.0279481,
  "found": true,
  "blocked": false
}
```

Review counts arrive from Naver as strings with thousands separators. They leave
this actor as numbers, so you can sort and average them without cleaning first.

### Use cases

**Lead lists for anyone selling to Korean small business.** A POS vendor, a
delivery platform, a supplier or an agency all need the same thing: every
business of a given type in a given area, with a phone number and an address that
matches the one on their paperwork. One query per district, the road address and
the phone on every row, and the review counts as a rough size proxy, gives you a
list you can work through rather than a map you have to click.

**Local SEO and listing audits.** Korean local search is a Naver problem, not a
Google problem. Pulling every competitor in a category and neighbourhood gives
you the ranking order Naver actually shows, along with each competitor's review
score, visitor review count and blog review count. Tracking that weekly tells
you whether a client is gaining on the businesses above them, and the split
between visitor and blog counts tells you whether a rival is earning attention
or buying it.

**Market entry and site selection.** Before opening anything in Korea you need
to know what is already there. Search a category across a list of neighbourhoods
and you get density, the review-score distribution and the coordinates to plot
it. A district with forty cafes averaging 4.2 is a different proposition from
one with twelve averaging 4.8, and both are different from one where half the
entries are flagged as newly opened.

**Travel and hospitality data.** The stays and attractions surfaces return hotels,
guesthouses, museums and parks with the same field set as restaurants. Combined
with coordinates and Naver Booking flags, that is enough to build an itinerary
tool or to enrich an existing travel product with the Korean listings it is
missing.

### How it compares

| | This actor | `delicious_zebu/naver-map-search-results-scraper` | `huggable_quote/naver-map-scraper` |
|---|---|---|---|
| Price per place | $0.0025 | $0.0015 plus $0.00005 per run | $0.003 plus $0.00005 per run |
| Cost of a 200-row run | $0.50 | $0.30 | $0.60 |
| Both review counts split out | yes | not published | not published |
| Coordinates on every row | yes | not published | yes |
| Category codes as well as names | yes | no | no |
| Says when it was refused | yes | no | no |
| Reviews text | no | no | yes |

`delicious_zebu` is the cheaper option and the honest comparison says so. What
you get here for the difference is the visitor / blog review split, Naver's
numeric category codes, and a run that tells you when it was refused instead of
handing you an empty dataset. `huggable_quote` reads individual review text,
which this actor does not do at all; if you need the reviews themselves rather
than the counts, that is the one to use.

### Pricing

Billing is pay-per-event at $0.0025 per place delivered. A refused read costs
nothing: if the site does not serve us, you get a row saying so and no charge for
it. All pricing is pay-per-event — you only pay for results you receive. No
actor-start fee, no per-compute-unit charges.

### Limits and gotchas

- Naver Map covers South Korea. Addresses, categories and business names come
  back in Korean, and that is the data, not a setting.
- One page holds 50 places, so a `maxItems` of 500 is ten requests and takes
  minutes rather than seconds.
- A search returns a large total but you cannot page through all of it forever.
  Naver ranks results, and the tail of a broad query is padded with weak matches,
  so a tight query across several districts beats one loose query paged deep.
- `visitor_review_score` is empty for places with too few reviews to score. That
  is Naver declining to average three ratings, not a missing field, and it is
  left empty rather than filled with a zero that would drag your averages down.
- Opening hours are a single line as the business wrote it, not a structured
  weekly schedule. Some businesses publish none at all.
- This actor reads the place list. It does not read individual review text, menus
  or photo galleries from the place page.
- The site refuses some requests. The actor retries, and if every attempt is
  refused you get a row with `blocked` set and the run summary says
  `siteRefusedUs`. Treat that as "come back later", not as "no such places".

### FAQ

**Can I scrape Naver Map without an API key?**
Yes. This actor needs no key, no Naver account and no cookies from you. The
official Naver Local Search API needs a registered application and returns five
results per call with no review data, which is why most people end up here.

**How do I get Korean restaurant data with review scores?**
Set `businessType` to restaurants and search a district in Korean, for example
`강남 카페` or `홍대 맛집`. Every row carries the visitor review score and both
review counts.

**Does Naver Map data include phone numbers?**
Yes, where the business publishes one. When a business only exposes Naver's
forwarding number, that number is used instead, so the field is rarely empty for
an active business.

**Can I search Naver Map near specific coordinates?**
Yes. Set `latitude` and `longitude` and the search is centred on that point, so
results come back ordered by distance from it.

**Why does my Naver Map search return Korean text?**
Because the businesses are Korean and that is how Naver files them. Names,
categories and addresses are stored in Korean, so translating them would mean
inventing data rather than reporting it.

### Related Actors

- [Avito Scraper](https://apify.com/s-r/avito-scraper)
- [Google Maps Scraper](https://apify.com/s-r/free-google-maps-scraper)
- [TripAdvisor Restaurants Scraper](https://apify.com/s-r/tripadvisor-restaurants)

# Actor input Schema

## `query` (type: `string`):

What to search for on Naver Map. Korean gives the fullest results, for example '강남 카페' for Gangnam cafes or '서울 치과' for Seoul dentists, but Latin-script brand names work too.

## `businessType` (type: `string`):

Which Naver Map list to search. The general search covers everything; the others rank and filter the way Naver's own category tabs do, so a restaurant search returns food-specific ordering and facets.

## `latitude` (type: `string`):

Optional. Centre the search on a point, so results come back ordered by distance from it and each row carries a distance. Pair with longitude.

## `longitude` (type: `string`):

Optional. Centre the search on a point, so results come back ordered by distance from it and each row carries a distance. Pair with latitude.

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

Stop after this many places. Naver returns 50 per page, so 200 is four pages. Free-plan runs are capped at 10 rows regardless of this number.

## Actor input object example

```json
{
  "query": "강남 카페",
  "businessType": "place",
  "latitude": "37.4979",
  "longitude": "127.0276",
  "maxItems": 50
}
```

# Actor output Schema

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

One row per place.

## `output` (type: `string`):

Counts, whether the search was genuinely empty or we were refused, and whether a proxy was configured.

## `errors` (type: `string`):

Refused reads and input problems.

# 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 = {
    "query": "강남 카페",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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 = {
    "query": "강남 카페",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("s-r/naver-map-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 '{
  "query": "강남 카페",
  "maxItems": 50
}' |
apify call s-r/naver-map-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/naver-map-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/e5Mvjt3uOjDs66GCJ/builds/l5GsKjFIKi4dXtjCJ/openapi.json