# Naver Shopping Scraper & Keyword Rank Tracker (`magenta_courser/naver-shopping-rank-tracker`) Actor

Enter Naver Shopping keywords and get ranked Plus Store products (verified to rank 1,000) for 6 sort orders, with price, discount, store, rating, reviews, stock and delivery. Add your product IDs or store names to get free summary rows with your rank, store ranks and price gap to #1.

- **URL**: https://apify.com/magenta\_courser/naver-shopping-rank-tracker.md
- **Developed by:** [SUNGHWAN CHO](https://apify.com/magenta_courser) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 products

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 Shopping Keyword Rank Tracker

Enter **Naver Shopping keywords** and get the **organic ranks in the Naver Plus Store product list** (Smart Store and Brand Store sellers) for each keyword and sort order as flat JSON rows: rank, price, discount, store, rating, reviews, stock and delivery flags. You choose the depth: top 100 by default; we have tested full scans to **rank 1,000**. Add your own **product IDs** or **store names** and you also get **free summary rows** per keyword and sort order: your product's rank and price gap to the #1 product, and every rank your store holds. Naver Shopping (search.shopping.naver.com) is the shopping search of Naver, South Korea's major portal. This Actor covers its Plus Store product list in **6 sort orders**, not ads and not price-comparison offers from external malls. Only one input is required: `keywords`.

### What you get

One row per product, in Naver's order, from rank 1 to `maxRank` (`"type": "product"`):

- `rank` (organic position in the Naver Plus Store list), keyword, sort order and total result count
- Naver Shopping product ID (`nvMid`), Smart Store product number (`channelProductId`), catalog ID, name, image and product URL
- Price, original price and discount %
- Store name, store ID and slug, store URL, store grade, official store and Brand Store flags
- Rating, review count and review count in the last 6 months
- Stock quantity and sold-out flag
- Shipping fee, free shipping, arrival guarantee and today delivery flags, free returns
- Overseas, second-hand and new-product flags, option count, number of sellers on the same catalog, category IDs
- Search URL, timestamp, `source` (`naver-shopping`) and `schemaVersion` on every row

One summary row per keyword × sort order × tracked product (`"type": "myProductSummary"`, only if you set `myProductIds`):

- `found`, `rank` and how many times the product appears
- `ranksScanned`, `searchStatus`, `stopReason` and `sortCheck`, so you can tell "not within the scanned ranks" from "search did not finish"
- Your price, discount, rating, review count and stock
- The #1 product's ID, name, store and price, and your price gap to it in KRW and %

One summary row per keyword × sort order × tracked store (`"type": "myStoreSummary"`, only if you set `myStoreNames`):

- `found`, best rank, number of the store's products within `maxRank`, average rank and the list of ranks
- The store's best-ranked product and its price, and the #1 product's price

Summary rows, the run summary and failed searches are **not charged**. Only product rows are.

No login and no browser: each page of 100 products is a plain HTTP request through a Korean residential proxy, with normal TLS certificate verification.

#### Why depth matters

A product or store that sits outside the first page still has a rank. In one of our runs for `무선 이어폰` (wireless earbuds) with `maxRank` 1000, the store `필립스 오디오 공식몰` (Philips Audio official store) had **7 products within the top 1,000** in Naver ranking, at ranks `1, 2, 49, 60, 313, 444, 454`. With page 1 only, four of them would have been invisible. You choose the depth per run: 100 for daily tracking, 1,000 for an occasional deep scan.

### Use cases

- **Daily rank tracking for Smart Store sellers and brands** — schedule a run with your main keywords and product IDs, and log your rank per keyword and sort order every day
- **Store visibility** — see how many of your store's products rank for each keyword, and where (`productsInRanks`, `ranks`)
- **Competitor price monitoring** — compare your price with the #1 product (`priceDiffVsTopPercent`) and with every product above you
- **Market scans for brands entering Korea** — the top 1,000 Plus Store products for a category keyword with prices, stores, reviews and delivery options, in one table
- **Agency and market reports** — one table across keywords and sort orders, ready for Google Sheets, BI tools or an LLM
- **AI agents** — one required input (`keywords`), flat English field names, numbers as numbers, missing values as `null`

### Input

| Field | Description |
|---|---|
| `keywords` | **Required.** Search keywords, one per line. Korean keywords match what shoppers type: `무선 이어폰` (wireless earbuds), `강아지 사료` (dog food), `선크림` (sunscreen). |
| `sorts` | Sort orders to check. Default `["REL"]`. `REL` = Naver ranking (the default view), `PURCHASE` = most purchased, `REVIEW` = most reviews, `LOW_PRICE` = lowest price, `HIGH_PRICE` = highest price, `RECENT` = newest. Each keyword is searched once per sort order. |
| `maxRank` | How deep to scan each keyword and sort order. Default `100`. One request per 100 ranks. This is also the number of charged rows per keyword and sort order. Tested end to end up to `1000`; the input accepts up to `10000` (where Naver's list ends), but scans deeper than 1,000 have not been tested end to end. |
| `myProductIds` | Optional. Your products: `nvMid`, Smart Store product number or product URL, e.g. `13103686932` or `https://smartstore.naver.com/yourstore/products/13103686932`. Adds one free summary row per keyword and sort order for each product. |
| `myStoreNames` | Optional. Your stores: store name as shown on Naver, Smart Store URL or the store ID from that URL, e.g. `필립스 오디오 공식몰` or `philipsav_official`. Spaces and letter case are ignored. Adds one free summary row per keyword and sort order for each store. |
| `proxyConfiguration` | Keep the default: Apify residential proxy, country `KR`. Naver Shopping blocks many data-center IPs. |
| `maxRequests` | Optional. Request limit for the whole run, retries included. Default: 2 per 100 ranks per search + 5. |
| `maxRunMinutes` | Optional. Time limit for the run, default 60 minutes. |

```json
{
  "keywords": ["무선 이어폰", "선크림", "강아지 사료"],
  "sorts": ["REL", "LOW_PRICE"],
  "maxRank": 100,
  "myProductIds": [
    "https://smartstore.naver.com/philipsav_official/products/13103686932",
    "90648198024"
  ],
  "myStoreNames": ["필립스 오디오 공식몰", "philipsav_official"]
}
```

One search = one keyword × one sort order = `maxRank` product rows (fewer if Naver has fewer results). The example above runs 6 searches and returns 600 product rows plus 24 summary rows (2 products and 2 store names × 6 searches).

### Output

The examples below are real rows from runs of the previous version (0.1). Fields added in version 0.2 (`schemaVersion`, `source`, status and history fields) are shown with the values the current version gives for the same result.

A product row from a real run of the input above (`무선 이어폰`, Naver ranking):

```json
{
  "schemaVersion": 2,
  "source": "naver-shopping",
  "type": "product",
  "keyword": "무선 이어폰",
  "sort": "REL",
  "rank": 1,
  "nvMid": "90648198024",
  "channelProductId": "13103686932",
  "originalMallProductId": "13045611896",
  "catalogId": "53920444078",
  "name": "필립스 커널형 무선 블루투스 이어폰 TAT1109",
  "price": 19900,
  "originalPrice": 99000,
  "discountRate": 79,
  "storeName": "필립스 오디오 공식몰",
  "storeId": "102274527",
  "storeSlug": "philipsav_official",
  "storeUrl": "https://smartstore.naver.com/philipsav_official",
  "storeGrade": "PREMIUM",
  "isOfficialStore": true,
  "officialStoreType": "OFFICIAL_BRAND_MALL",
  "isBrandStore": true,
  "rating": 4.75,
  "reviewCount": 3384,
  "reviewCount6Months": 3360,
  "stockQuantity": 640,
  "isSoldOut": false,
  "shippingFee": 0,
  "isFreeShipping": true,
  "fastDeliveryType": "ARRIVAL_GUARANTEE",
  "isArrivalGuarantee": true,
  "isTodayDelivery": false,
  "isFreeReturn": false,
  "isOverseas": false,
  "isSecondhand": false,
  "isNew": false,
  "optionCount": 2,
  "catalogSellerCount": 1,
  "categoryId": "50024439",
  "categoryPath": "50000003>50000209>50024379>50024439",
  "imageUrl": "https://shopping-phinf.pstatic.net/main_9064819/90648198024.jpg",
  "url": "https://smartstore.naver.com/main/products/13103686932",
  "totalResults": 228785,
  "searchUrl": "https://search.shopping.naver.com/ns/search?query=%EB%AC%B4%EC%84%A0%20%EC%9D%B4%EC%96%B4%ED%8F%B0",
  "scrapedAt": "2026-10-01T12:55:09.772Z"
}
```

A product summary row from another run (`maxRank` 1000, sorts `REL` and `REVIEW`, `myProductIds: ["13103686932"]`). The same product was #1 in Naver ranking and #76 by most reviews:

```json
{
  "schemaVersion": 2,
  "source": "naver-shopping",
  "type": "myProductSummary",
  "keyword": "무선 이어폰",
  "sort": "REVIEW",
  "productId": "13103686932",
  "found": true,
  "rank": 76,
  "appearances": 1,
  "nvMid": "90648198024",
  "channelProductId": "13103686932",
  "name": "필립스 커널형 무선 블루투스 이어폰 TAT1109",
  "storeName": "필립스 오디오 공식몰",
  "price": 19900,
  "originalPrice": 99000,
  "discountRate": 79,
  "rating": 4.75,
  "reviewCount": 3384,
  "stockQuantity": 639,
  "topProductNvMid": "83603589898",
  "topProductName": "리큐엠 20000mAh 잔량표시 고속충전 대용량 보조배터리 QP2000C 단품",
  "topProductStoreName": "리큐엠 공식몰",
  "topProductPrice": 36900,
  "priceDiffVsTop": -17000,
  "priceDiffVsTopPercent": -46.1,
  "ranksScanned": 1000,
  "maxRank": 1000,
  "searchStatus": "completed",
  "stopReason": "maxRank",
  "sortCheck": "monotonic",
  "url": "https://smartstore.naver.com/main/products/13103686932",
  "searchUrl": "https://search.shopping.naver.com/ns/search?query=%EB%AC%B4%EC%84%A0%20%EC%9D%B4%EC%96%B4%ED%8F%B0&sort=REVIEW",
  "scrapedAt": "2026-10-01T12:56:23.864Z"
}
```

A store summary row from the same run (`myStoreNames: ["필립스 오디오 공식몰"]`, Naver ranking):

```json
{
  "schemaVersion": 2,
  "source": "naver-shopping",
  "type": "myStoreSummary",
  "keyword": "무선 이어폰",
  "sort": "REL",
  "store": "필립스 오디오 공식몰",
  "found": true,
  "bestRank": 1,
  "productsInRanks": 7,
  "averageRank": 189,
  "ranks": "1, 2, 49, 60, 313, 444, 454",
  "storeName": "필립스 오디오 공식몰",
  "storeSlug": "philipsav_official",
  "storeUrl": "https://smartstore.naver.com/philipsav_official",
  "bestProductNvMid": "90648198024",
  "bestProductName": "필립스 커널형 무선 블루투스 이어폰 TAT1109",
  "bestProductPrice": 19900,
  "topProductPrice": 19900,
  "ranksScanned": 1000,
  "maxRank": 1000,
  "searchStatus": "completed",
  "stopReason": "maxRank",
  "sortCheck": "default",
  "searchUrl": "https://search.shopping.naver.com/ns/search?query=%EB%AC%B4%EC%84%A0%20%EC%9D%B4%EC%96%B4%ED%8F%B0",
  "scrapedAt": "2026-10-01T12:56:15.666Z"
}
```

**What `found` means:**

- `found: true` — the product or store is among the saved rows of this search.
- `found: false` — the search completed and the product or store was not within ranks 1 to `ranksScanned`. Its rank and price fields are `null`; the #1 product fields are still filled. It may rank lower than you scanned.
- `found: null` — the search did not finish (`searchStatus` is `partial`, `failed`, `budgetLimited` or `notStarted`), so absence is unknown. A partial search can still return `found: true` with the ranks it saved.

The dataset has three views: **Products**, **My product summary** and **My store summary**. To get one kind of row through the API or an export, filter on `type`.

#### Run summary

The key-value store record `RUN_SUMMARY` has the run's `stopReason`, the number of product rows saved (equal to the product rows in the dataset), the request and time limits, and one entry per keyword × sort order search with `productsSaved`, `ranksScanned`, pages, Naver's total and:

| `status` | Meaning |
|---|---|
| `completed` | All requested ranks were saved. `stopReason`: `maxRank`, `endOfResults` (Naver's list ended earlier) or `noResults` |
| `partial` | Some pages were saved, then a later page failed (`blocked`, `schemaError`, `sortNotApplied`). The saved ranks are charged; the rest are not. |
| `failed` | The first page failed in all retries. Not charged. `schemaError` means Naver answered in a format the Actor does not understand (reported separately from "no results"). |
| `budgetLimited` | Stopped by a run limit: `chargeLimit` (your maximum cost per run), `requestBudget` or `timeLimit` |
| `notStarted` | The run stopped before this search began. `stopReason` is the run's reason. |

#### How sort orders are checked

`sortCheck` in `RUN_SUMMARY` and in summary rows says how the sort order was confirmed. Naver's response has no "applied sort" field (as of October 2026), so:

- `monotonic` — `LOW_PRICE`, `HIGH_PRICE` and `REVIEW` pages are checked against prices or review counts (at least 75% of neighbouring products in order, since Naver's price order is not strict). A page that fails is retried and, if it stays wrong, the search fails without charge. A correctly sorted page is accepted even when it happens to equal the default order.
- `differsFromDefault` / `sameAsDefault` — `PURCHASE` and `RECENT` have no checkable value in the data (no sales count, no date). Page 1 is compared with the default order only as a hint. `sameAsDefault` searches are **kept**, not dropped, but treat them with care.
- `default` — `REL` needs no check.

Export as JSON, CSV or Excel, or read through the Apify API.

### Tips

- **Daily tracking:** schedule the Actor once a day with the same input and append the datasets. Use `keyword` + `sort` + `productId` (or `store`) to line up days.
- **Choose depth by cost:** you pay per product row, so `maxRank` drives the bill. 10 keywords × 1 sort order × `maxRank` 100 = 1,000 rows per run. Keep 100 for daily tracking and use 1,000 or more for occasional deep scans.
- **Any product ID works:** a `myProductIds` entry matches `nvMid`, `channelProductId` (the number in a Smart Store URL), `originalMallProductId` or `catalogId`. In our tests the same Philips product was found by its Smart Store number and by its `nvMid`.
- **Store names:** the store's display name, its Smart Store slug (`philipsav_official`) and its store ID all match. The `ranks` list shows up to the first 50 ranks.
- **Price gap is most useful in `REL` and `PURCHASE`.** In `LOW_PRICE`, #1 is often a bait or accessory listing (in our runs, 10 KRW and 60 KRW items for `무선 이어폰` and `선크림`), so `priceDiffVsTop` there says little about real competitors.
- Text values (names, store names) are in Korean, as shown on Naver. Prices are in KRW. Category fields are Naver category IDs; category names are not included.
- Naver reports products without a discount as `discountRate: 0` with `originalPrice` equal to `price`, and products without reviews as `rating: 0` and `reviewCount: 0`. Fields Naver leaves empty are `null`: `catalogId` (product not matched to a catalog), `officialStoreType`, `fastDeliveryType`.

### Notes and limits

- **Organic ranks in the Naver Plus Store product list.** Ranks follow Naver's own product list (the data behind search.shopping.naver.com/ns/search). **Ads and other cards that Naver mixes into the search page are not included**, so the position you see on screen can differ from `rank`. There is no ad rank field, and ranks are what a logged-out shopper is served at the time of the run.
- **Naver Plus Store products only.** Products from Smart Store and Brand Store sellers are included. Price-comparison offers from external malls (Coupang, 11st and others) are not.
- **No sales counts.** Naver's `PURCHASE` order is available as a sort, but the number of units sold is not.
- **Depth: tested to rank 1,000.** Our cloud tests scanned ranks 1 to 1,000 for several keywords and sort orders with no gaps or duplicates. Naver's list ends at rank 10,000 (we saw 100 products at rank 9,901 and none after 10,000 in a spot check), and `maxRank` accepts up to 10,000, but full scans deeper than 1,000 have not been tested end to end. `RECENT` usually returns far fewer products (1,099 for `무선 이어폰` in our test).
- **Price sorts keep Naver's own order.** Naver's lowest-price and highest-price lists are not always strictly ordered by price; `rank` is the order Naver returned.
- **Korean residential proxy is required.** The default proxy setting (Apify residential, country `KR`) is what we tested. Apify lists residential proxy on all plans, including Free.
- **Blocking and retries:** Naver blocks some automated requests with an "access temporarily restricted" page. Each page is retried with a fresh Korean IP up to 6 times. If a later page still fails, the search keeps the ranks it already has (`searchStatus: partial`); if the first page fails, the search is marked `failed` in `RUN_SUMMARY` and **is not charged**. If 10 requests in a row are blocked, the run stops (`stopReason: blocked`), and the request limit (`maxRequests`) caps the total. If Naver changes its site or blocking rules, searches can fail for a while until the Actor is updated.
- **Maximum cost per run:** when your limit is reached, the run stops, `RUN_SUMMARY.productsSaved` equals the product rows in the dataset, the cut search is `budgetLimited` with the ranks it saved, and the rest are `notStarted`.
- Results show what a logged-out shopper in Korea sees at the time of the run. Ranks and prices change during the day.
- This Actor collects only publicly visible search results. It does not log in, and it collects no reviews, reviewer data or seller personal data.

# Actor input Schema

## `keywords` (type: `array`):

Required. Search keywords to check on Naver Shopping (search.shopping.naver.com), one per line, typed as a Korean shopper would. Examples: 무선 이어폰 (wireless earbuds), 강아지 사료 (dog food), 선크림 (sunscreen). Each keyword is searched once per sort order in the Naver Plus Store product list (Smart Store and Brand Store products; no ads, no external malls).

## `sorts` (type: `array`):

Optional. Sort orders to check; default \["REL"]. Each keyword is searched once per sort order and every row has a "sort" field. REL = Naver ranking (the default order shoppers see), PURCHASE = most purchased, REVIEW = most reviews, LOW\_PRICE = lowest price, HIGH\_PRICE = highest price, RECENT = newest. Ranks are organic only (no ads). LOW\_PRICE, HIGH\_PRICE and REVIEW are checked against prices and review counts; a page that is not in that order is retried and, if it stays wrong, the search fails without charge. PURCHASE and RECENT cannot be checked from the data; if page 1 matches the default order the search is kept and marked sortCheck = sameAsDefault.

## `maxRank` (type: `integer`):

Optional. How deep to scan each keyword and sort order: products ranked 1 to maxRank are returned, 100 per request. Default 100. We have tested full scans up to rank 1,000; Naver's list stops at rank 10,000, which is the maximum accepted here, but scans deeper than 1,000 have not been tested end to end. You are charged per product row, so maxRank is also your row count per keyword and sort order: 3 keywords x 2 sorts x maxRank 100 = up to 600 charged rows.

## `myProductIds` (type: `array`):

Optional. Your products to track, one per line: Naver Shopping product ID (nvMid), Smart Store product number, or a product URL. Examples: 13103686932, 90648198024, https://smartstore.naver.com/yourstore/products/13103686932. For each keyword and sort order you get one free row (type = myProductSummary) with the rank, price and price gap to the #1 product. found = false means the product was not within the ranksScanned ranks of a completed search; found = null means the search did not finish (see searchStatus and stopReason), so absence is unknown.

## `myStoreNames` (type: `array`):

Optional. Stores to track, one per line: store name as shown on Naver, Smart Store URL, or the store ID from that URL (spaces and letter case are ignored). Examples: 필립스 오디오 공식몰 (Philips Audio official store), philipsav\_official, https://smartstore.naver.com/philipsav\_official. For each keyword and sort order you get one free row (type = myStoreSummary) with the store's best rank, average rank and how many of its products are within the scanned ranks. found follows the same rules as for products.

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

Keep the default: Apify residential proxy, country KR (South Korea). Naver Shopping blocks many data-center IPs. Change it only if you have your own Korean residential proxies.

## `maxRequests` (type: `integer`):

Optional. Upper limit on HTTP requests for the whole run, retries included. Default: 2 per 100 ranks per search + 5. When it is used up, the run stops, keeps what it saved and marks unfinished searches as budgetLimited or notStarted in RUN\_SUMMARY.

## `maxRunMinutes` (type: `integer`):

Optional. The run stops sending new requests after this many minutes, default 60, and keeps what it saved. Independent of this, the run also stops after 10 blocked requests in a row (stopReason = blocked) instead of retrying every remaining page.

## Actor input object example

```json
{
  "keywords": [
    "무선 이어폰"
  ],
  "sorts": [
    "REL"
  ],
  "maxRank": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "KR"
  }
}
```

# Actor output Schema

## `products` (type: `string`):

Ranked products (type = product) for each keyword and sort order and, if you set product IDs or store names, summary rows (type = myProductSummary / myStoreSummary).

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

Run status (stopReason, products saved, request and time limits) and one entry per keyword and sort order search with status (completed, partial, failed, budgetLimited, notStarted), stopReason, productsSaved and ranksScanned. Failed searches are not charged.

# 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 = {
    "keywords": [
        "무선 이어폰"
    ],
    "sorts": [
        "REL"
    ],
    "maxRank": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "KR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("magenta_courser/naver-shopping-rank-tracker").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 = {
    "keywords": ["무선 이어폰"],
    "sorts": ["REL"],
    "maxRank": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "KR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("magenta_courser/naver-shopping-rank-tracker").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 '{
  "keywords": [
    "무선 이어폰"
  ],
  "sorts": [
    "REL"
  ],
  "maxRank": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "KR"
  }
}' |
apify call magenta_courser/naver-shopping-rank-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,magenta_courser/naver-shopping-rank-tracker"
        }
    }
}
```

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/WgUrm5UZmbOEUj8ft/builds/HTkgKiftBxE1jMnIt/openapi.json