# Naver Place Review Classifier — complaints & sponsors · $0.5/1k (`leoworks/naver-place-review-classifier`) Actor

Naver Place review analysis (네이버 플레이스 리뷰): complaint types, sentiment, unanswered reviews; blog posts sponsored or not. Not for Google Maps (use leoworks/google-maps-review-classifier). Input placeUrls or datasetId. Cost: $0.5/1k judged + ~$1/1k collected by a separate scraper, billed to you.

- **URL**: https://apify.com/leoworks/naver-place-review-classifier.md
- **Developed by:** [Leoworks](https://apify.com/leoworks) (community)
- **Categories:** AI, Marketing, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.43 / 1,000 review classifications

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

**Part of LeoWorks review tools:** Naver Place reviews → complaints and reply queue (this Actor) · Google Maps reviews ([Google Maps Review Classifier](https://apify.com/leoworks/google-maps-review-classifier)) · Korean shopping and app reviews ([Korean Review Classifier](https://apify.com/leoworks/korean-review-classifier)).

**Analyze Naver Place reviews (네이버 플레이스 리뷰) — paste the place links of your restaurants or cafés.** This Actor collects the newest visitor reviews of each place and labels every one with **complaint types (taste, food condition, hygiene, service, wait, price and portion, atmosphere, facilities and parking), sentiment and an owner-reply flag**. It tells you which reviews **still have no owner reply**, and, if you switch it on, labels the **blog posts written about the place as sponsored or not**. The output is a table, a reply-queue CSV and a per-place summary. Already have reviews? Pick the dataset of a Naver Place scraper, or paste review texts. Judging costs **$0.50 per 1,000 reviews**; the collection step adds about $1.00 per 1,000, so **about $1.50 per 1,000 reviews all-in**. No prompts, no LLM key.

> **Who collects the reviews:** when you enter **Places**, the reviews are collected by a separate Actor, [Naver Place Reviews + Blog scraper by huggable_quote](https://apify.com/huggable_quote/naver-place-reviews-scraper) — not by this Actor. Apify bills that Actor to your account at its own price (about **$0.001 per review**; it can change). This Actor adds **$0.0005 per judged review**. Collection needs a Korean residential proxy, which the Actor requests for you and Apify bills to your account at its proxy rate. Reviewer names and profile links are never copied into the output.

### What can the Naver Place Review Classifier do?

- **Collects the reviews for you** — paste a place link or its numeric place ID, or classify a dataset you already have
- **Complaint types for restaurants and cafés** — 9 types: taste, food condition, hygiene and foreign objects, staff and service, waiting, price and portion, atmosphere and noise, facilities and parking, other — multi-label, each with a probability
- **Sentiment** — positive / neutral / negative
- **Reply queue** — reviews that need an owner reply and still have none, as a CSV
- **Serious-issue flag** — food poisoning, injury, pests or foreign objects, discrimination, fraud accusations and legal threats
- **Sponsored blog posts (optional, beta)** — each blog post about the place is labelled `disclosed` (the post itself states a sponsorship or fee), `suspected` (reads like an advertisement) or `none`, with a promotion score you can threshold yourself
- **Your own labels** — up to 10 yes/no criteria in plain language (for example "mentions parking")

**Use it to:** answer unanswered complaints first · see why a branch loses stars (wait? taste? staff?) · check which blogs near your place read like paid promotion · compare branches · feed labelled reviews to a dashboard or an AI agent.

**Works from Claude, Cursor or Claude Code** — add it as a tool through the Apify MCP server and ask in plain language (see **API, MCP and integrations** below).

### How to analyze Naver Place reviews

**Option A — enter the places (the Actor collects the reviews):**

1. In **Places**, paste the place's own link (`map.naver.com/p/entry/place/…`, `m.place.naver.com/…` or `naver.me/…`) or just its numeric place ID — one per line, up to 20. The place ID is the number at the end of the Naver Map link of the place.
2. Set **Reviews per place** (the newest reviews first; default 50, up to 200).
3. Optional: switch on **Also judge blog posts about each place**, or add **Custom labels**.
4. Click **Start**. The run log shows the estimated cost before anything is collected, and one place takes about a minute. If you set a maximum cost per run, the Actor lowers the reviews per place to stay within it.
5. In **Output**, open **Classified reviews**, or download `REPLY_QUEUE.csv` and `REPORT_PLACES.csv`.

**Search terms are best effort.** The **Search terms** field (for example `성수 맛집`) asks Naver's directory for places. Naver blocks searches intermittently: in our tests more than half of the searches found no place. Place links and IDs were reliable (27 of 27 places collected). Use links or IDs when you need a result.

**Option B — you already have reviews:**

1. Run a Naver Place reviews scraper for the places you care about, or use any dataset with a review text field.
2. Open this Actor, pick the dataset in **Reviews dataset** (or paste texts to try it). Fields such as `reviewText`, `reviewRating`, `reviewDate` and `reviewReplyText` are detected automatically.
3. Click **Start** and open the same outputs.

#### Run it automatically after every scrape

In your Naver Place scraper (or its saved task), open **Integrations → Add integration → Apify Actor**, choose this Actor and set its input to:

```json
{ "datasetId": "{{resource.defaultDatasetId}}" }
```

### Pricing

Pay only for judged reviews — no subscription.

| Event | Price | When |
|---|---|---|
| `review-judged` | $0.0005 | One Naver Place review judged: complaint types, sentiment and reply-needed flag for a visitor review (plus any custom labels), or the sponsorship label for a blog post. Items that fail or have no text are not charged. |

#### How much does it cost to analyze Naver Place reviews?

That is **$0.50 per 1,000 reviews** for judging. When you enter **Places**, the collection is billed to you on top (about $0.001 per review, its price; the run log shows the live estimate): **about $1.50 per 1,000 reviews all-in**.

**Cost examples (judging only)**

| Reviews | Cost |
|---|---|
| 100 | $0.05 |
| 1,000 | $0.50 |
| 10,000 | $5.00 |
| 100,000 | $50.00 |

With the free $5 monthly Apify credit you can judge about **10,000 reviews**.

| Run | Collection (separate Actor) | Judging (this Actor) | Total |
|---|---|---|---|
| 1 place, 50 reviews | about $0.05 | $0.025 | **about $0.075** |
| 1 place, 100 reviews + 10 blog posts | about $0.11 | $0.055 | **about $0.165** |
| 10 places × 100 reviews + 10 blog posts each | about $1.10 | $0.55 | **about $1.65** |

Reviews without text are skipped and **not charged**. Reviews that fail after retries are reported with an `error` field and **not charged**. Blog posts, when switched on, are collected and judged at the same prices as reviews. Residential proxy traffic is billed by Apify at its proxy rate; text responses are small, check the Usage of your run.

#### Is it free to try?

Yes. The free $5 monthly Apify credit covers about **10,000 judged reviews**, or about **3,300** when this Actor also collects them. The form defaults collect and judge the 50 newest reviews of one place for about **$0.08**.

### Input and output examples

#### Output sample

Examples from our own test runs on public Naver Place reviews (October 2026). Review text is shortened, the reviewer name is not part of the output, and the star column is left out where the example does not show it.

| review | stars | complaints | sentiment | needs a reply |
|---|---|---|---|---|
| 해산물이 상태가 안 좋아 푸석이고 비린내가 심해요. 실망 그 자체입니다. | — | food condition, taste | negative | **yes** |
| 중앙시장 수산시장 횟집들이 점점 비싸지는듯요. 비추합니다. | — | price | negative | **yes** |
| 그냥 살짝 맵기만 하고…깊은 맛도 아닌 얼큰하지도 않고 싱거워서 넘 실망했어요 | — | taste | negative | **yes** |
| 직원들도 친절하고 고기류가 좋았네요 … 대게는 반절은 속이 다 비어있엇음 | — | food condition, other | negative | **yes** |
| 다 맛있어요. 잘 먹었습니다. | 5 | none | positive | no |

Most Naver visitor reviews are 5-star (87% of the 900 we collected for one test run), so the labels come from the text, not from the stars.

**Blog post** — each blog post about the place gets `sponsorship` and a `sponsorPromotionalScore` between 0 and 1:

```json
{
  "reviewType": "blog",
  "placeName": "…",
  "sponsorship": "suspected",
  "sponsorPromotionalScore": 0.8,
  "sponsorDisclosedProbability": 0.04
}
```

#### Input example

```json
{
  "placeUrls": ["https://map.naver.com/p/entry/place/1924779962", "11726468"],
  "reviewsPerPlace": 100,
  "includeBlogReviews": true,
  "blogPerPlace": 10,
  "customLabels": ["mentions parking"]
}
```

#### Which Naver link or place ID can I use?

A place's own link (`map.naver.com/p/entry/place/<id>`, `m.place.naver.com/<type>/<id>/…`, `naver.me/…` short links) or the numeric `<id>`. A search page or a list page is not a place.

#### Output files and columns

- **Classified reviews** (dataset): one row per review or blog post — `reviewType`, `placeName`, `labels.complaint` (types with probabilities), `labels.sentiment`, `labels.needsReply`, `labels.alert`, `unanswered` when the data has the owner reply field, `sponsorship` for blog posts, `text` (first 500 characters), `reviewUrl`.
- **`REPLY_QUEUE.csv`**: reviews that need a reply and have none.
- **`REPORT_PLACES.csv` / `REPORT`**: per place — complaint mix, sentiment, unanswered count and, with blog posts, the sponsorship mix.
- **`SUMMARY`**: counts, cost and what was skipped.
- A complaint that fits none of the 9 types but sits in a clearly negative or reply-worthy review is reported as `other` with `inferred: true`.

### API, MCP and integrations

#### Works with

- [Naver Place Reviews + Blog scraper](https://apify.com/huggable_quote/naver-place-reviews-scraper) — the collection step; also usable on its own, then pick its dataset here.
- [Korean Review Classifier](https://apify.com/leoworks/korean-review-classifier) — Korean shopping and app reviews.
- [Google Maps Review Classifier](https://apify.com/leoworks/google-maps-review-classifier) — reviews of places on Google Maps.

#### Call it from code

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('leoworks/naver-place-review-classifier').call({
    placeUrls: ['1924779962'],
    reviewsPerPlace: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((r) => r.labels?.unanswered));
```

#### Use with Claude, Cursor or Claude Code (MCP)

Add the Apify MCP server with this Actor as a tool (`https://mcp.apify.com?tools=leoworks/naver-place-review-classifier`) and ask, for example: "Judge the newest 50 Naver Place reviews of place 1924779962 and list the unanswered complaints."

### Accuracy and limits

#### Accuracy

We measured the labels against a **separate set of reviews collected after the labels were tuned** (9 places, 149 visitor reviews and 60 blog posts). The correct answers were written by **independent LLM labelers working from a written guide — not by humans**. Intervals are Wilson 95%; `n` is the number of items behind the figure.

**Headline: tuned to miss little.** About **9 in 10 real complaints are caught**; about **1 in 4 flagged reviews is not a real complaint**, so a person should look at what is flagged.

| What | Result (Wilson 95% lower–upper) | n |
|---|---|---|
| A complaint is present — recall | 27/30 = **90.0%** (74.4–96.5%) | 30 |
| A complaint is present — precision | 27/37 = **73.0%** (57.0–84.6%) | 37 |
| Sentiment (3 classes) | 143/149 = **96.0%** (91.5–98.1%) | 149 |
| Needs a reply — recall | 13/13 = **100%** (77.2–100%) | 13 |
| Needs a reply — precision | 13/19 = **68.4%** (46.0–84.6%) | 19 |
| Blog post `suspected` at 0.8 (default) — precision | 21/22 = **95.5%** (78.2–99.2%) | 22 |
| Blog post `suspected` at 0.8 (default) — recall | 21/33 = **63.6%** (46.6–77.8%) | 33 |
| Blog post `suspected` at 0.7 — precision / recall | 27/29 = **93.1%** (78.0–98.1%) / 27/33 = **81.8%** (65.6–91.4%) | 29 / 33 |
| Serious-issue flag | not measurable: no such review in this set | 0 |
| Blog post `disclosed` | not measurable: only 3 posts state a sponsorship | 3 |

In 100 reviews that had no candidate label we found 0 complaints (0/100, upper bound 3.7%).

**Complaint types — reference only.** The per-type figures come from an earlier, larger set (300 visitor reviews, labeled with an earlier guide) and are **not comparable** with the table above. A type is marked *reference only* when its precision is below 70% or it has fewer than 20 flagged reviews.

| Type | Precision (n flagged) | Recall (n real) | Status |
|---|---|---|---|
| Taste | 91.8% (45/49) | 81.8% (45/55) | |
| Staff and service | 92.5% (37/40) | 88.1% (37/42) | |
| Price and portion | 89.7% (26/29) | 89.7% (26/29) | |
| Food condition | 87.5% (21/24) | 60.0% (21/35) | |
| Waiting | 50.0% (9/18) | 81.8% (9/11) | reference only |
| Atmosphere and noise | 64.3% (9/14) | 75.0% (9/12) | reference only |
| Facilities and parking | 81.8% (9/11) | 90.0% (9/10) | reference only (n < 20) |
| Hygiene and foreign objects | 5/6 | 5/5 | reference only (n < 10) |
| Other | 64.1% (25/39) | 75.8% (25/33) | reference only |

These types often occur together in one review, so they are less sharp than the yes/no "is there a complaint" figure. Whether a review enters the reply queue depends on the yes/no figure, not on the type.

**Three cautions**

1. The correct answers were written by LLM labelers, not by humans, and the labelers marked about one review in five as a boundary case (28 of 149).
2. The result depends on the places: the same Actor scored 93% precision on an earlier set of 18 other places (after we tuned it on that set) and 73% on the new set. Expect different results on your places.
3. Most false flags are short positive reviews such as "너무 핫있고 음식도 이뻐요" that get a type attached.

#### Limits

- Up to 20 places and 200 reviews per place per run when the Actor collects the reviews.
- Visitor reviews and blog posts only; no photos, no menus, no business details.
- Naver can rate-limit the collection step; the Actor then ends with a clear message and charges nothing for the failed step. Use **Reviews dataset** with data you already have.
- Blog posts are judged from the title and the beginning of the post (the first part of the text, often about 750–1,300 characters). A sponsorship statement later in the post is not seen.
- The labels are statistical. Do not use them alone to accuse a blogger or to take a legal step.

### More Actors from LeoWorks

- [Korean Review Classifier](https://apify.com/leoworks/korean-review-classifier) — sentiment and complaint types for Korean reviews.
- [Google Maps Review Classifier](https://apify.com/leoworks/google-maps-review-classifier) — complaint types and reply queue for Google Maps reviews.
- [Google Maps Lead Qualifier](https://apify.com/leoworks/google-maps-lead-qualifier) — places to qualified leads.

### FAQ and support

#### How do I analyze Naver Place reviews?

Paste the place link or its numeric ID in **Places** and click **Start**, or pick the dataset of a Naver Place scraper in **Reviews dataset**.

#### Who collects the reviews and who is billed?

A separate Actor ([Naver Place Reviews + Blog scraper](https://apify.com/huggable_quote/naver-place-reviews-scraper)) collects them and Apify bills it to your account. This Actor charges only for judged reviews and blog posts.

#### Does it collect reviewer names or profiles?

No. Reviewer names, profile links and user IDs are never copied into the output. A blog post keeps its own link (`reviewUrl`), which contains the address of that blog. Review text is truncated to 500 characters in the dataset.

#### Does it write the owner replies?

No. It tells you which reviews need one and which are still unanswered (when the data has the owner reply field).

#### How do I find a place ID?

Open the place on Naver Map; the number after `/place/` in the address bar is the ID.

#### Which AI makes the judgments?

A Jev classifier model: each label is a yes/no question with a probability, so you can raise or lower the threshold with **Complaint threshold** (default 0.5) and **Sponsored-post threshold** (default 0.8).

#### Is it legal to analyze Naver reviews?

The Actor reads public pages through a separate scraper. You are responsible for using the data in line with Naver's terms and applicable law, including Korean data protection law. Do not use it to identify or contact private individuals.

#### Disclaimer

Labels are statistical estimates and can be wrong; see **Accuracy and limits**. Sponsorship labels describe how a text reads, not what the author was paid. This Actor is not affiliated with Naver.

#### Reviews and support

Questions or a problem? Open an issue on the Actor's page. Tell us the run ID and what you expected; we reply there.

### Changelog

See [CHANGELOG.md](CHANGELOG.md).

# Changelog

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

# Actor input Schema

## `placeUrls` (type: `array`):

One place per line, up to 20 (see “Max places”). Paste a place's own link (map.naver.com/p/entry/place/…, m.place.naver.com/…, naver.me/…) or its numeric place ID. The reviews are collected for you by a separate scraper (huggable_quote/naver-place-reviews-scraper, about $0.001 per review) that Apify bills to your account; this Actor then judges them ($0.0005 per review). Use this and/or “Search terms”, OR “Reviews dataset” OR “Review texts”.

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

Look places up in Naver's directory, for example “강남 맛집” or “성수 카페” (a place type with an area, or a business name). Each term takes the first places it finds; the total is capped by “Max places”. A topic or a question matches nothing — to name one place use “Places” instead.

## `maxPlaces` (type: `integer`):

At most this many places per run when the reviews are collected for you (place links plus search results). The cost of the collection step is about $0.001 per review plus the judging price.

## `reviewsPerPlace` (type: `integer`):

How many of the newest visitor reviews to collect for each place when the reviews are collected for you. The maximum cost per run lowers this if needed.

## `includeBlogReviews` (type: `boolean`):

Collect the blog and cafe posts written about each place and label each one: states a sponsorship or fee (disclosed), reads like promotion (suspected) or neither. Posts are billed like reviews by the scraper and by this Actor. Off by default.

## `blogPerPlace` (type: `integer`):

Blog posts to collect per place when blog posts are on (10, 20 or 30; other values are rounded down to 10).

## `datasetId` (type: `string`):

An Apify dataset containing Naver Place reviews — for example the output of a Naver Place reviews scraper (huggable_quote, oxygenated_quagmire, zen-studio). Visitor reviews and blog posts can be mixed. Use this OR “Places”/“Search terms” (not both); it takes priority over “Review texts”.

## `texts` (type: `array`):

Paste visitor review texts directly (one per line) when you already have them. Ignored when “Places”, “Search terms” or “Reviews dataset” is set.

## `customLabels` (type: `array`):

Up to 10 extra yes/no labels (each up to 200 characters) in plain language, e.g. “mentions parking”, “complains about a specific employee”. Each gets a probability.

## `reviewsNewerThan` (type: `string`):

Classify only reviews published after this date — a date like `2026-01-01` or a period like `90 days`, `6 months`, `1 year`. Needs a review date in the dataset (e.g. `publishedAtDate`). Leave empty for all.

## `maxStars` (type: `integer`):

For example 3 = classify only 1–3 star reviews (the ones that usually need attention). 0 = all ratings. Reviews without a star rating are kept.

## `maxReviewsPerPlace` (type: `integer`):

Classify at most this many reviews per place (counted in dataset order — Naver Place scrapers list the newest first when sorted by newest). With “Places”, this is how many of the newest reviews to collect per place (0 = 50). 0 = no limit for a dataset.

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

Classify at most this many reviews (0 = all).

## `textField` (type: `string`):

Field holding the review text. Leave empty to auto-detect (text, reviewText, review, …).

## `extraTextFields` (type: `array`):

Fields to prepend to the text (up to 5). Leave empty if unsure.

## `idFields` (type: `array`):

Fields copied unchanged from each input item to the output so you can join results back (e.g. reviewId, placeId). Leave empty to auto-pick reviewId and placeId.

## `ratingField` (type: `string`):

Leave empty to auto-detect (stars, rating, …).

## `dateField` (type: `string`):

Leave empty to auto-detect (publishedAtDate, date, …). Used for the monthly trend, the last-90-days comparison and the date filter.

## `ownerReplyField` (type: `string`):

Leave empty to auto-detect (responseFromOwnerText, ownerResponse, …). Used for “unanswered” and the reply queue.

## `placeNameField` (type: `string`):

Leave empty to auto-detect (title, placeName). Not `name` — in review datasets that is usually the reviewer.

## `complaintThreshold` (type: `number`):

Minimum probability (0–1) for a complaint type, the owner-reply flag or a custom label to be reported. Raise it for fewer, surer labels.

## `suspectedThreshold` (type: `number`):

Minimum promotion score (0–1) for a blog post that does not state a sponsorship to be labelled `suspected`. 0.8 flags only posts that read like brochures and rarely points at an honest author; 0.7 finds more but also flags ordinary enthusiastic reviews. The score is always in `sponsorPromotionalScore`.

## `outputMode` (type: `string`):

Minimal mode returns only label keys — smaller and easier to aggregate.

## `summaryGroupField` (type: `string`):

Field in your dataset that identifies the business (e.g. `placeId`, `title`). The run then saves a REPORT record with, per place: complaint rate and complaint mix, sentiment shares, average rating, reviews needing an owner reply (and how many are still unanswered) and 3 example complaints. Leave empty to detect it automatically. No extra charge.

## `maxConcurrency` (type: `integer`):

Reviews classified in parallel.

## `healthCheck` (type: `boolean`):

Internal: fail the run when results look degraded (used by the developer's scheduled checks).

## Actor input object example

```json
{
  "placeUrls": [
    "https://map.naver.com/p/entry/place/1818558157"
  ],
  "maxPlaces": 5,
  "reviewsPerPlace": 50,
  "includeBlogReviews": false,
  "blogPerPlace": 10,
  "customLabels": [],
  "maxStars": 0,
  "maxReviewsPerPlace": 20,
  "maxItems": 0,
  "extraTextFields": [],
  "idFields": [],
  "complaintThreshold": 0.5,
  "suspectedThreshold": 0.8,
  "outputMode": "full",
  "maxConcurrency": 10,
  "healthCheck": false
}
```

# Actor output Schema

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

No description

## `summary` (type: `string`):

No description

## `report` (type: `string`):

No description

## `placesCsv` (type: `string`):

No description

## `replyQueue` (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 = {
    "placeUrls": [
        "https://map.naver.com/p/entry/place/1818558157"
    ],
    "maxReviewsPerPlace": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("leoworks/naver-place-review-classifier").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 = {
    "placeUrls": ["https://map.naver.com/p/entry/place/1818558157"],
    "maxReviewsPerPlace": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("leoworks/naver-place-review-classifier").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 '{
  "placeUrls": [
    "https://map.naver.com/p/entry/place/1818558157"
  ],
  "maxReviewsPerPlace": 20
}' |
apify call leoworks/naver-place-review-classifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,leoworks/naver-place-review-classifier"
        }
    }
}
```

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/IAvXwLKisphMD1YnX/builds/0pJnbgBKxtWSXsPMA/openapi.json