# Naver Shopping Reviews Scraper (`delicious_zebu/naver-shopping-reviews-scraper`) Actor

Scrape customer reviews from any Naver SmartStore or Brand Store product by URL: star rating, text, date, photos & videos, the option/SKU bought, repurchase & best-review flags, seller replies, and an AI review summary. Sort by ranking/latest/rating; filter by star, media, and more.

- **URL**: https://apify.com/delicious\_zebu/naver-shopping-reviews-scraper.md
- **Developed by:** [ВAH](https://apify.com/delicious_zebu) (community)
- **Categories:** E-commerce, Developer tools, SEO tools
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

Naver Shopping Reviews Scraper extracts **customer reviews** from any [Naver SmartStore](https://smartstore.naver.com) or Brand Store product — just paste the product URLs. You get the full review record a shopper sees: star rating, full text, date, **review photos and videos**, the exact option/SKU the buyer purchased, repurchase and "best review" flags, helpful-vote counts, and Naver's own topic tags. A fast, no-code **Naver reviews API alternative**.

### What does Naver Shopping Reviews Scraper do?

Give it one or more Naver product detail URLs (`smartstore.naver.com/{store}/products/{id}` or `brand.naver.com/{brand}/products/{id}`) and it returns **one structured record per review** — rating, text, date, photo/video URLs, the purchased option, helpful votes, and more — with product context attached to every row. Sort reviews the same way Naver does (Ranking, Latest, Highest/Lowest rating) and optionally filter by star rating or to photo/video reviews only.

### Why use Naver Shopping Reviews Scraper?

- **Just paste product URLs** — no keywords, no login, no configuration.
- **Both store types** — SmartStore and Brand Store.
- **Review photos & videos** — direct image URLs and video thumbnails/IDs, not just text. Perfect for UGC and visual analysis.
- **The exact option bought** — each review carries the SKU/option the reviewer purchased (e.g. color, size, flavor), so you can analyze feedback per variant.
- **Native sort & filters** — Ranking / Latest / Highest rating / Lowest rating, plus star-rating and photo-video filters. "Lowest rating" surfaces complaints in seconds.
- **Seller replies** — capture the store's official reply to each review, ideal for seeing how sellers handle complaints.
- **Built-in product review summary** — every row carries the product's AI review tags, star-rating breakdown, review-type counts, and rating-aspect percentages (taste, packaging, freshness…), so you get the whole-product picture without a second scrape.
- **Rich signals competitors miss** — repurchase & free-trial flags, "best review" flag, helpful-vote counts, Naver AI topic tags (taste, delivery, design…), and buyer survey info (household, purpose).
- **Self-contained rows** — every review includes product name, URL, store, average rating, and total review count, so the output drops straight into CSV/Excel.

#### How this Actor compares

| Feature | This Actor | Other Naver review tools |
| --- | --- | --- |
| Input | Precise product URLs | Whole-brand only |
| Photos & videos | ✅ URLs + IDs | ❌ |
| Option/SKU bought | ✅ | ❌ |
| Sort options | 4 (Naver-native) | ❌ |
| Star / media filters | ✅ | ❌ |
| Helpful votes, best-review, repurchase | ✅ | ❌ |
| Seller replies to reviews | ✅ | ❌ |
| Product AI summary & rating breakdown | ✅ | ❌ |
| Fields per review | 28 | ~8 |

#### Common use cases

- **Voice-of-customer & sentiment** — mine review text and topic tags at scale.
- **Complaint mining** — sort by Lowest rating or filter to 1–2 stars.
- **Per-variant feedback** — group reviews by the purchased option.
- **UGC collection** — pull review photos and videos for a product.
- **Competitor & brand monitoring** — track ratings and review velocity over time.

### What data can you extract?

Each review is one dataset item:

| Field | Type | Description |
| --- | --- | --- |
| `reviewId` | number | Unique Naver review ID |
| `rating` | number | Star rating, 1–5 |
| `reviewContent` | string | Full review text |
| `reviewDate` | string | Review date (YYYY-MM-DD) |
| `modifyDate` | string | Last-edited date; empty if the review was never edited |
| `reviewType` | string | `NORMAL` or `AFTER_USE` (one-month/after-use review) |
| `contentType` | string | `TEXT`, `PHOTO`, or `VIDEO` |
| `repurchase` | boolean | Whether the reviewer marked it a repurchase |
| `freeTrial` | boolean | Whether it is a free-trial / sponsored review |
| `bestReview` | boolean | Whether Naver/seller flagged it a best review |
| `helpfulCount` | number | Number of "helpful" votes |
| `optionPurchased` | string | The option/SKU the reviewer bought |
| `images` | array | Review photo URLs |
| `videos` | array | Review videos: `{ thumbnail, videoId }` |
| `topics` | array | Naver AI topic tags (e.g. 맛/taste, 배송/delivery, 디자인/design) |
| `reviewerInfo` | array | Buyer survey values (e.g. household size, purpose) — when available |
| `sellerReply` | string | The store's official reply to this review; empty when none |
| `writerId` | string | Reviewer ID, masked by Naver (e.g. `umy8***`) |
| `writerProfileImage` | string | Reviewer avatar URL (empty for default avatars) |
| `productId` | string | Product ID |
| `productName` | string | Product name |
| `productUrl` | string | Product page URL |
| `storeName` | string | Store / brand name |
| `productRating` | number | Product average rating |
| `productReviewCount` | number | Product total review count |
| `productReviewSummary` | object | Product-level summary (same on every review of the product): `aiTags`, `scoreDistribution` (1–5★ counts), `recentAverageRating`, `reviewTypeCounts`, `evaluations` (rating-aspect %), `topics` |
| `sourceUrl` | string | The input URL |
| `scrapedAt` | string | Scrape timestamp |

### How to scrape Naver reviews

1. Open the Actor on Apify.
2. Copy a product URL from `smartstore.naver.com` or `brand.naver.com`.
3. Paste one or more URLs into **Product URLs**.
4. (Optional) Choose a **sort order**, a **max reviews per product**, **star ratings**, or **photo/video only**.
5. Click **Start**, then download results as **JSON, CSV, Excel**, or via the [Apify API](https://docs.apify.com/api/v2).

### How much does it cost?

Runs on Apify's pay-as-you-go platform. Cost scales with the number of reviews you collect. Use **Max reviews per product** to cap spend, or set it to 0 to pull everything. New Apify accounts include free monthly credits.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `productUrls` | array of strings | Naver product detail URLs (SmartStore or Brand Store). **Required.** |
| `sortBy` | string | `Ranking` (랭킹순, default), `Latest` (최신순), `Highest rating` (평점 높은순), `Lowest rating` (평점 낮은순). |
| `maxReviewsPerProduct` | integer | Max reviews per product. `0` = all. Default `100`. |
| `starRatings` | array | Only these ratings, e.g. `["1","2"]`. Empty = all. |
| `mediaOnly` | boolean | Only photo/video reviews (Naver's 포토·동영상). Default `false`. |
| `storePickOnly` | boolean | Only "Store PICK" / best reviews (스토어PICK). Default `false`. |
| `afterUseOnly` | boolean | Only one-month-use reviews (한달사용리뷰). Default `false`. |
| `repurchaseOnly` | boolean | Only repurchase reviews (재구매). Default `false`. |

```json
{
  "productUrls": [
    "https://smartstore.naver.com/pasteur365/products/11150965069",
    "https://brand.naver.com/lumena/products/13244298880"
  ],
  "sortBy": "Ranking",
  "maxReviewsPerProduct": 100,
  "starRatings": [],
  "mediaOnly": false,
  "storePickOnly": false,
  "afterUseOnly": false,
  "repurchaseOnly": false
}
````

### Output

Each review becomes one dataset item (text truncated for readability):

```jsonc
{
  "productName": "GOT MILK 유럽산 수입멸균우유 믈레코비타 갓밀크 1L(12입)",
  "productRating": 4.86,
  "productReviewCount": 117,
  "productReviewSummary": {           // product-level; identical on every review of this product
    "aiTags": ["유통기한이 길어요", "라떼로 먹기 좋아요", "맛있어요", "가성비가 좋아요", "..."],
    "scoreDistribution": { "5": 104, "4": 10, "3": 3, "2": 0, "1": 0 },
    "recentAverageRating": 4.84,
    "reviewTypeCounts": { "text": 44, "photo": 71, "video": 2, "normal": 76, "afterUse": 41, "best": 0 },
    "evaluations": [
      { "name": "맛 만족도", "question": "맛은 어떤가요?", "values": [ { "name": "맛있어요", "percent": 88, "count": 103 }, "..." ] }
    ],
    "topics": ["맛", "만족도", "배송", "유통기한", "포장"]
  },
  "reviewId": 4983850388,
  "rating": 5,
  "reviewContent": "1L 1,825원으로 아주 싸게 유럽우유를 마시고 있습니다. 멸균제품이라서 비린내가 안 나서 편하게 마십니다...",
  "reviewDate": "2026-05-25",
  "reviewType": "AFTER_USE",          // NORMAL or AFTER_USE (one-month review)
  "contentType": "VIDEO",             // TEXT / PHOTO / VIDEO
  "optionPurchased": "제품선택: 갓밀크3.5%(12입)",
  "repurchase": false,
  "bestReview": false,                // true when flagged as a best review
  "freeTrial": false,                 // true for free-trial / sponsored reviews
  "helpfulCount": 0,                  // "helpful" votes
  "images": [
    "https://phinf.pstatic.net/checkout.phinf/20260525_86/...X8jE1_JPEG/20260525_121235.jpg",
    "https://phinf.pstatic.net/checkout.phinf/20260525_192/...D0PbS_JPEG/20260525_073251.jpg"
  ],
  "videos": [
    { "thumbnail": "https://phinf.pstatic.net/image.nmv/.../rvgjB7wjnV_03.jpg", "videoId": "4F0D30DD4D6093C32B021C737345A19B6E2B" }
  ],
  "topics": [],                       // AI topic tags; [] when none detected
  "reviewerInfo": [],                 // buyer survey; [] when the product has no survey
  "sellerReply": "",                  // store's reply to this review; "" when none
  "writerId": "imyu******",           // Naver-masked
  "writerProfileImage": "https://phinf.pstatic.net/contact/.../wanderer_above_the_mist.jpg",
  "modifyDate": "",                   // last-edited date; empty if never edited
  "productId": "11150965069",
  "storeName": "파스퇴르365",
  "productUrl": "https://smartstore.naver.com/main/products/11150965069",
  "sourceUrl": "https://smartstore.naver.com/pasteur365/products/11150965069",
  "scrapedAt": "2026-07-12 12:00:00"
}
```

A text review with topic tags and buyer survey info looks like this:

```jsonc
{
  "reviewId": 5013851865,
  "rating": 4,
  "reviewContent": "가성비 좋아요~ 국산우유가 맛나지만 비싸잖아요~",
  "reviewDate": "2026-07-04",
  "reviewType": "AFTER_USE",
  "contentType": "TEXT",
  "repurchase": false,
  "helpfulCount": 0,
  "optionPurchased": "제품선택: 아이러브 1.5%저지방우유(12입)",
  "images": [],
  "videos": [],
  "topics": ["만족도", "맛"],          // satisfaction, taste
  "reviewerInfo": ["1인", "싱글"],     // 1-person household, single
  "writerId": "mave***",
  "productId": "11150965069",
  "productName": "GOT MILK 유럽산 수입멸균우유 믈레코비타 갓밀크 1L(12입)",
  "storeName": "파스퇴르365",
  "productRating": 4.86,
  "productReviewCount": 117
}
```

A **1-star review with the seller's official reply** — ideal for complaint analysis:

```jsonc
{
  "reviewId": 4957303843,
  "rating": 1,
  "reviewContent": "일단은 이거 신는거 고려해보셔합니다. 신고 벗기가 너무...",
  "reviewDate": "2026-04-19",
  "reviewType": "AFTER_USE",
  "contentType": "PHOTO",
  "repurchase": false,
  "freeTrial": false,
  "optionPurchased": "Ankle H-01: Ankle H-01 M (225~240mm)",
  "images": ["https://phinf.pstatic.net/checkout.phinf/20260419_71/...image.jpg"],
  "sellerReply": "안녕하세요, 고객님!\n받아보신 상품 착용법이 다소 번거로우셨던 것 같아 죄송한 마음입니다ㅜㅠ ...",
  "writerId": "red5***",
  "storeName": "혁선생",
  "productRating": 4.7,
  "productReviewCount": 1762
  // ...same product-context fields as the examples above
}
```

### Tips

- **Use full product URLs** copied from the browser address bar. Both SmartStore and Brand Store are supported; price-comparison/catalog pages (`shopping.naver.com/catalog/...`) are not.
- **Cap large products** with `maxReviewsPerProduct`. Popular products can have tens of thousands of reviews — set it to `0` only when you truly want them all.
- **Find complaints fast** — set `sortBy` to `Lowest rating`, or `starRatings` to `["1","2"]`.
- **`topics` and `reviewerInfo` vary by product** — some categories return rich tags/survey answers, others return none. They arrive as `[]` when unavailable.
- **`videos`** provide a thumbnail and Naver video ID; `images` are direct photo URLs.
- Schedule runs to track ratings and review velocity over time, or trigger via the [Apify API](https://docs.apify.com/api/v2) and [integrations](https://docs.apify.com/platform/integrations).

### FAQ and support

**Is web scraping legal?** Scraping publicly available data is generally legal. This Actor collects only publicly visible review information that Naver displays on every product page, and reviewer IDs are already masked by Naver. You are responsible for complying with GDPR and other regulations in how you use the data.

**Which URLs are supported?** Naver SmartStore and Brand Store product detail pages. Price-comparison / catalog pages are not supported.

**Something not working or a field missing?** Reach out via Apify support or leave a message on the Actor's page.

### Related Naver Actors

Looking for more Naver Shopping data? Check out my other Naver scrapers:

1. **[Naver Product Detail Scraper](https://apify.com/delicious_zebu/naver-product-detail-scraper)** — Extract a product's full record from any SmartStore or Brand Store URL: price, per-SKU options & stock, images, review stats, delivery, and the complete seller/business profile.
2. **[Naver Shopping Product Scraper](https://apify.com/delicious_zebu/naver-shopping-product-scraper)** — Search Naver Shopping by keyword and collect product listings at scale: price, seller, ratings, and more. Ideal for product discovery and market research.

***

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

# Actor input Schema

## `productUrls` (type: `array`):

Naver product detail page URLs to scrape reviews from. Supports both SmartStore (smartstore.naver.com/{store}/products/{id}) and Brand Store (brand.naver.com/{brand}/products/{id}) links. Paste the full product page URL from your browser's address bar.

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

Order in which reviews are collected — the same four options shown in Naver's review section: Ranking (랭킹순), Latest (최신순), Highest rating (평점 높은순), Lowest rating (평점 낮은순). 'Lowest rating' is the fastest way to surface complaints/negative feedback.

## `maxReviewsPerProduct` (type: `integer`):

Maximum number of reviews to collect per product. Set to 0 to collect ALL reviews (can be thousands for popular products). Default 100.

## `starRatings` (type: `array`):

Only collect reviews with these star ratings. Leave empty to collect all ratings. Example: select 1 and 2 stars to gather only negative reviews.

## `mediaOnly` (type: `boolean`):

When enabled, collect only reviews that contain photos or videos (Naver's '포토·동영상 리뷰' filter). Useful for gathering user-generated images of a product.

## `storePickOnly` (type: `boolean`):

When enabled, collect only reviews Naver/the seller flagged as best reviews (Naver's '스토어PICK' filter).

## `afterUseOnly` (type: `boolean`):

When enabled, collect only 'after-use' reviews written after about a month of use (Naver's '한달사용리뷰' filter).

## `repurchaseOnly` (type: `boolean`):

When enabled, collect only reviews from repeat buyers (Naver's '재구매' filter).

## Actor input object example

```json
{
  "productUrls": [
    "https://smartstore.naver.com/pasteur365/products/11150965069"
  ],
  "sortBy": "Ranking",
  "maxReviewsPerProduct": 100,
  "starRatings": [],
  "mediaOnly": false,
  "storePickOnly": false,
  "afterUseOnly": false,
  "repurchaseOnly": false
}
```

# Actor output Schema

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

Table view of reviews using the 'overview' view from dataset\_schema.json.

## `rawResults` (type: `string`):

All review items from the default dataset without a specific view.

# 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 = {
    "productUrls": [
        "https://smartstore.naver.com/pasteur365/products/11150965069",
        "https://brand.naver.com/lumena/products/13244298880",
        "https://smartstore.naver.com/richocean/products/6272899246"
    ],
    "maxReviewsPerProduct": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("delicious_zebu/naver-shopping-reviews-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 = {
    "productUrls": [
        "https://smartstore.naver.com/pasteur365/products/11150965069",
        "https://brand.naver.com/lumena/products/13244298880",
        "https://smartstore.naver.com/richocean/products/6272899246",
    ],
    "maxReviewsPerProduct": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("delicious_zebu/naver-shopping-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "productUrls": [
    "https://smartstore.naver.com/pasteur365/products/11150965069",
    "https://brand.naver.com/lumena/products/13244298880",
    "https://smartstore.naver.com/richocean/products/6272899246"
  ],
  "maxReviewsPerProduct": 100
}' |
apify call delicious_zebu/naver-shopping-reviews-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=delicious_zebu/naver-shopping-reviews-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver Shopping Reviews Scraper",
        "description": "Scrape customer reviews from any Naver SmartStore or Brand Store product by URL: star rating, text, date, photos & videos, the option/SKU bought, repurchase & best-review flags, seller replies, and an AI review summary. Sort by ranking/latest/rating; filter by star, media, and more.",
        "version": "1.0",
        "x-build-id": "5t24vFmNYHaaX6gDB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/delicious_zebu~naver-shopping-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-delicious_zebu-naver-shopping-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/delicious_zebu~naver-shopping-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-delicious_zebu-naver-shopping-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/delicious_zebu~naver-shopping-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-delicious_zebu-naver-shopping-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "Naver product detail page URLs to scrape reviews from. Supports both SmartStore (smartstore.naver.com/{store}/products/{id}) and Brand Store (brand.naver.com/{brand}/products/{id}) links. Paste the full product page URL from your browser's address bar.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "Ranking",
                            "Latest",
                            "Highest rating",
                            "Lowest rating"
                        ],
                        "type": "string",
                        "description": "Order in which reviews are collected — the same four options shown in Naver's review section: Ranking (랭킹순), Latest (최신순), Highest rating (평점 높은순), Lowest rating (평점 낮은순). 'Lowest rating' is the fastest way to surface complaints/negative feedback.",
                        "default": "Ranking"
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per product. Set to 0 to collect ALL reviews (can be thousands for popular products). Default 100.",
                        "default": 100
                    },
                    "starRatings": {
                        "title": "Star ratings (optional filter)",
                        "type": "array",
                        "description": "Only collect reviews with these star ratings. Leave empty to collect all ratings. Example: select 1 and 2 stars to gather only negative reviews.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "5",
                                "4",
                                "3",
                                "2",
                                "1"
                            ],
                            "enumTitles": [
                                "5 stars",
                                "4 stars",
                                "3 stars",
                                "2 stars",
                                "1 star"
                            ]
                        },
                        "default": []
                    },
                    "mediaOnly": {
                        "title": "Photo & video reviews only",
                        "type": "boolean",
                        "description": "When enabled, collect only reviews that contain photos or videos (Naver's '포토·동영상 리뷰' filter). Useful for gathering user-generated images of a product.",
                        "default": false
                    },
                    "storePickOnly": {
                        "title": "Store PICK reviews only",
                        "type": "boolean",
                        "description": "When enabled, collect only reviews Naver/the seller flagged as best reviews (Naver's '스토어PICK' filter).",
                        "default": false
                    },
                    "afterUseOnly": {
                        "title": "One-month-use reviews only",
                        "type": "boolean",
                        "description": "When enabled, collect only 'after-use' reviews written after about a month of use (Naver's '한달사용리뷰' filter).",
                        "default": false
                    },
                    "repurchaseOnly": {
                        "title": "Repurchase reviews only",
                        "type": "boolean",
                        "description": "When enabled, collect only reviews from repeat buyers (Naver's '재구매' filter).",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```