# Korea Local Data MCP Server (Naver Map, Kakao Map) (`magenta_courser/korea-local-data-mcp`) Actor

MCP server that lets AI agents search Korean places on Naver Map and Kakao Map and read Naver Place visitor reviews. Give a keyword such as 성수 카페 (Seongsu cafes) or a place ID and get flat JSON. No login, no API key for Naver or Kakao.

- **URL**: https://apify.com/magenta_courser/korea-local-data-mcp.md
- **Developed by:** [SUNGHWAN CHO](https://apify.com/magenta_courser) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 tool calls

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Korea Local Data MCP Server (Naver Map, Kakao Map)

An MCP server that gives AI agents live **Korean local business data**: search places on **Naver Map** and **Kakao Map**, and read **Naver Place visitor reviews**. Connect it to Claude, ChatGPT, Cursor or any MCP client and ask in plain language:

- "Find the top 20 cafes in Seongsu on Naver Map and summarize what reviewers say about the top 3."
- "List dermatology clinics near Gangnam Station with phone numbers."
- "Compare the Naver and Kakao ratings of restaurants in Euljiro."

Google Maps coverage of South Korea is thin. Naver Map and Kakao Map are what people in Korea actually use, so this is where the complete listings, ratings and reviews are.

No Naver or Kakao login or API key is needed. You only need an Apify account.

### Tools

| Tool | Input | Returns |
|---|---|---|
| `search_naver_places` | `query` (Korean keyword such as `성수 카페`), `maxPlaces` 1–100 (default 20) | Places in Naver's ranking order: name, category, address, phone, coordinates, rating (`visitorReviewScore`), visitor and blog review counts, booking flag, amenities, Naver Map URL |
| `get_naver_place_reviews` | `place` (Naver place id or Naver Map URL), `maxReviews` 1–100 (default 20) | The place's average rating and review count, plus the newest visitor reviews: rating, text, visit date, written date, keyword tags with English codes, ordered menu item, owner reply |
| `search_kakao_places` | `query`, `maxPlaces` 1–100 (default 15) | Places from Kakao Map with exactly the same fields as the Naver tool (`homepage` is filled on Kakao only) |

Every result also has `status` (`completed`, `partial` or `budgetLimited`), a `message` that explains anything unusual, `reportedTotal` (how many the site says exist) and `returnedCount`. Every field is always present; a value the site does not show is `null`. Numbers are numbers.

Reviewer names, profile pictures and user IDs are never requested or returned.

Korean keywords that combine an area and a category work best: `강남 맛집` (Gangnam restaurants), `홍대 미용실` (Hongdae hair salons), `부산 해운대 호텔` (Haeundae hotels). Agents usually translate an English request into such a keyword on their own.

### Connect

The MCP endpoint (Streamable HTTP) is:

```
https://magenta-courser--korea-local-data-mcp.apify.actor/mcp
```

Authenticate with your Apify API token as a Bearer token.

**Claude Code**

```bash
claude mcp add --transport http korea-local-data https://magenta-courser--korea-local-data-mcp.apify.actor/mcp --header "Authorization: Bearer YOUR_APIFY_TOKEN"
```

**Any client that takes a JSON config**

```json
{
  "mcpServers": {
    "korea-local-data": {
      "type": "http",
      "url": "https://magenta-courser--korea-local-data-mcp.apify.actor/mcp",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

### Example result

`search_naver_places` with `{"query": "성수 카페", "maxPlaces": 1}`:

```json
{
  "source": "naver",
  "query": "성수 카페",
  "status": "completed",
  "message": null,
  "reportedTotal": 2346,
  "returnedCount": 1,
  "places": [
    {
      "source": "naver",
      "query": "성수 카페",
      "rank": 1,
      "id": "1922651675",
      "name": "노틀던",
      "category": "카페,디저트",
      "businessType": "cafe",
      "roadAddress": "서울숲2길 11 1층",
      "address": "서울특별시 성동구 성수동1가 685-501 1층",
      "district": "서울 성동구 성수동1가",
      "phone": null,
      "latitude": 37.5473614,
      "longitude": 127.0400154,
      "visitorReviewScore": 4.97,
      "visitorReviewCount": 1160,
      "blogCafeReviewCount": 1463,
      "hasBooking": true,
      "amenities": ["포장", "예약", "단체 이용 가능", "간편결제", "제로페이"],
      "homepage": null,
      "url": "https://map.naver.com/p/entry/place/1922651675",
      "scrapedAt": "2026-10-02T17:35:22.080Z"
    }
  ]
}
```

One row of `get_naver_place_reviews` (`reviews[]`), next to the top-level `placeName`, `placeRating` and `placeReviewCount`:

```json
{
  "source": "naver",
  "placeId": "1922651675",
  "placeName": "노틀던",
  "reviewId": "6abf33448f9dd532461b9928",
  "rating": 5,
  "text": "디저트도 예쁘고 맛있어요!! 다른메뉴도 먹으러 또오고싶어요",
  "visitedAt": "2026-10-02T04:23:12.000Z",
  "createdAt": "2026-10-02T04:29:56.000Z",
  "visitCount": 1,
  "verificationType": "receipt",
  "menuItem": "노틀던 누아",
  "keywords": ["커피가 맛있어요", "디저트가 맛있어요", "아늑해요", "음악이 좋아요"],
  "keywordCodes": ["coffee_good", "dessert_good", "cozy", "music_good"],
  "hasOwnerReply": false,
  "ownerReply": null,
  "url": "https://map.naver.com/p/entry/place/1922651675?placePath=/review",
  "scrapedAt": "2026-10-02T17:35:26.980Z"
}
```

The place field names are the same as in the batch Actors listed below, so data from both can be merged.

### Pricing

Pay per event:

- `tool-call`: one per tool call that returns at least one item.
- `place`: one per place returned by `search_naver_places` or `search_kakao_places`.
- `review`: one per review returned by `get_naver_place_reviews`.

What you are not charged for:

- A tool call that fails (the site blocked the request, a wrong place id, invalid arguments) or returns nothing.
- Connecting, `initialize` and `tools/list`.
- Items you did not receive. If the run's spending limit cannot pay for everything you asked for, the result is cut to what was charged, `status` is `budgetLimited` and `message` says so. If only part of the pages could be read, you get and pay for that part (`status: "partial"`).

As with any Actor in Standby mode, the small container that serves your requests runs in your Apify account. It uses 256 MB and stops 60 seconds after your last request; in our tests one session cost about $0.001 of platform usage for a single call and about $0.002 for ten calls.

### Run it without an MCP client

You can also press **Start** (or call the Actor through the Apify API) to make one tool call. The items go to the run's dataset and a short summary to the key-value store record `RUN_SUMMARY`.

| Input | Meaning |
|---|---|
| `tool` | `search_naver_places` (default), `get_naver_place_reviews` or `search_kakao_places` |
| `query` | Search keyword for the two search tools, e.g. `성수 카페` |
| `place` | Naver place id or Naver Map URL for `get_naver_place_reviews` |
| `maxItems` | 1–100 places or reviews |

### Need bulk data instead?

This server is built for quick agent lookups (up to 100 items per call, answers in a few seconds). For large exports, scheduled monitoring, opening hours, menus, photos and full review histories, use the batch Actors. They cost less per item:

- [Naver Place Search Scraper](https://apify.com/magenta_courser/naver-place-search-scraper)
- [Naver Place Reviews Scraper](https://apify.com/magenta_courser/naver-place-reviews-scraper)
- [Kakao Map Place Search Scraper](https://apify.com/magenta_courser/kakaomap-place-search-scraper)

### Notes

- Names, categories, addresses and review text are returned in Korean, as shown on Naver and Kakao.
- Naver and Kakao place IDs are separate systems. To decide that two rows are the same business, compare phone, address and coordinates.
- Ratings on Naver and Kakao come from different reviewers and are not directly comparable. A place nobody has rated has `visitorReviewScore: null`.
- The first request after a pause takes 2-4 seconds longer while the server starts.
- Naver and Kakao sometimes reject requests. The server retries up to 4 times with a new proxy IP and gives up after about 45 seconds with a clear error; that call is free.
- Short `naver.me` links are not supported as input; use the full Naver Map URL or the numeric id.
- This server reads publicly visible listing and review content only and does not log in to any account.

# Actor input Schema

## `tool` (type: `string`):

Which tool to call. search_naver_places and search_kakao_places use "Search keyword"; get_naver_place_reviews uses "Naver place".

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

Keyword for the two search tools. Korean works best, e.g. 성수 카페 (Seongsu cafes), 강남 맛집 (Gangnam restaurants), 홍대 미용실 (Hongdae hair salons).

## `place` (type: `string`):

For get_naver_place_reviews: a Naver place ID (e.g. 1922651675, the "id" from search_naver_places) or a Naver Map URL such as https://map.naver.com/p/entry/place/1922651675.

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

How many places or reviews to return (1-100). Each returned item is billed. If empty, the tool default is used (20 for Naver, 15 for Kakao).

## Actor input object example

```json
{
  "tool": "search_naver_places",
  "query": "성수 카페",
  "maxItems": 10
}
```

# Actor output Schema

## `items` (type: `string`):

Items returned by the tool call, as dataset items.

## `runSummary` (type: `string`):

Tool, arguments, status (completed, partial, budgetLimited), message, reported total and returned count. Not billed.

# 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 = {
    "tool": "search_naver_places",
    "query": "성수 카페",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("magenta_courser/korea-local-data-mcp").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 = {
    "tool": "search_naver_places",
    "query": "성수 카페",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("magenta_courser/korea-local-data-mcp").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 '{
  "tool": "search_naver_places",
  "query": "성수 카페",
  "maxItems": 10
}' |
apify call magenta_courser/korea-local-data-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,magenta_courser/korea-local-data-mcp"
        }
    }
}
```

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/6EgtKSeg5op75i4QO/builds/Rn71rxv1YsHlkbuf2/openapi.json