# Naver DataLab Scraper - Shopping Insight & Keyword Trends API (`koreadata-lab/naver-shopping-insight-search-trends`) Actor

Naver Shopping Insight category and keyword click trends plus Naver search trends via the official NAVER API HUB, run with your own key. Compare 5+ keywords on one scale, split by device, gender and age, growth %.

- **URL**: https://apify.com/koreadata-lab/naver-shopping-insight-search-trends.md
- **Developed by:** [Koreadata Lab](https://apify.com/koreadata-lab) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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/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 DataLab Scraper - Shopping Insight & Keyword Trends API

A Naver DataLab scraper you can use as a **Naver keyword trends API**: it pulls **Naver search trends (검색어 트렌드)** and **Naver Shopping Insight (쇼핑인사이트)** click trends for Korean keywords and shopping categories, through the **official NAVER API HUB** (Naver Cloud Platform) instead of scraping pages. You run it with **your own API key**; it is analysis software for your own queries, not a data feed. Modes:

1. **Search trends** (`search`): relative search volume for keyword groups.
2. **Shopping category trends** (`shoppingCategory`): click trends of Naver Shopping categories.
3. **Shopping keyword trends** (`shoppingKeyword`): click trends of keywords inside one shopping category.
4. **Shopping breakdowns by device, gender or age**: `shoppingCategoryDevice`, `shoppingCategoryGender`, `shoppingCategoryAge` (per category) and `shoppingKeywordDevice`, `shoppingKeywordGender`, `shoppingKeywordAge` (per keyword in a category). Each segment (PC/mobile, male/female, 10s to 60+) gets its own series and its average share.

> **Live-tested on Apify: YES (2026-10-29).** Three search-trend groups (가습기, 공기청정기, 전기요), weekly, last 12 months: 3 summary rows in 3 s through NAVER API HUB keys. By default the last, unfinished week is left out so the latest value is not a false drop.

### What makes it different

- **Naver Shopping demand signals, legally.** Naver's shopping *search* API ended on 2026-07-31; Shopping Insight is the official way left to see what Korean shoppers click on Naver Shopping, by category and keyword.
- **Compare more than 5 keywords on ONE scale.** The API allows only 5 groups per call, and each call is scaled to its own max of 100. This actor adds an anchor keyword to every batch and re-scales the batches, so 50 keywords end up comparable.
- **Who is clicking:** device, gender and age splits with `averageSharePct` per segment.
- **Growth metrics ready to use:** `latestValue`, `peakPeriod`, `changeVsPreviousPct`, `recentVsPriorAvgPct` (4-period momentum), `isRising`.
- **Zero-filled, aligned series.** DataLab omits zero periods; we fill them so charts line up.
- **Two output shapes:** `series` (one row per group, best for agents and dashboards) or `points` (long format, best for Sheets and BI tools).
- **NAVER API HUB ready:** uses the Naver Cloud Platform endpoints first and still accepts old NAVER Developers keys as a fallback until they stop working on 2027-06-30.

### Input examples

Search trends, 3 groups:

```json
{
  "mode": "search",
  "keywordGroups": [ {"name": "humidifier", "keywords": ["가습기", "가열식가습기"]}, "공기청정기", "전기요" ],
  "timeUnit": "week", "startDate": "2025-10-01", "endDate": "2026-10-27",
  "apiHubClientId": "YOUR_API_HUB_CLIENT_ID", "apiHubClientSecret": "YOUR_API_HUB_CLIENT_SECRET"
}
```

Shopping clicks for a category by age:

```json
{ "mode": "shoppingCategoryAge", "shoppingCategories": [{"name": "Digital & appliances", "id": "50000003"}], "timeUnit": "month",
  "apiHubClientId": "YOUR_API_HUB_CLIENT_ID", "apiHubClientSecret": "YOUR_API_HUB_CLIENT_SECRET" }
```

Filters: `device` (pc/mo), `gender` (m/f), `ages`. Optional fallback keys: `legacyClientId` / `legacyClientSecret`. `apiProvider`: `auto` (API HUB, then legacy on 401/403), `apihub` or `legacy`. Without `startDate` / `endDate` the actor uses the last 12 months up to yesterday (KST).

### Output

Example (illustrative values), one row in `series` format. Here 공기청정기 was compared with 가습기 and 제습기 over five weeks:

```json
{
  "mode": "search", "groupName": "공기청정기", "keywords": ["공기청정기"], "categoryId": null, "timeUnit": "week",
  "startDate": "2026-01-05", "endDate": "2026-02-02", "filters": {"device": "all", "gender": "all", "ages": "all"},
  "latestValue": 45, "averageValue": 32.5, "peakValue": 45, "peakPeriod": "2026-02-02",
  "changeVsPreviousPct": 28.6, "changeVsFirstPct": 80, "recentVsPriorAvgPct": null, "isRising": null,
  "series": [
    {"period": "2026-01-05", "value": 25, "rawRatio": 50},
    {"period": "2026-01-12", "value": 27.5, "rawRatio": 55},
    {"period": "2026-01-19", "value": 30, "rawRatio": 60},
    {"period": "2026-01-26", "value": 35, "rawRatio": 70},
    {"period": "2026-02-02", "value": 45, "rawRatio": 90}
  ]
}
```

`value` is on the common 0 to 100 scale across all groups; `rawRatio` is what Naver returned for that one API call. `recentVsPriorAvgPct` and `isRising` need at least 8 periods, so they are `null` in this short example.
Breakdown modes add `breakdown` (`device` / `gender` / `age`), `segment` (`mo`, `f`, `30`, ...), `segmentEn` (`Mobile`, `Female`, `30s`, ...) and `averageSharePct` (for example `"segment": "mo", "segmentEn": "Mobile", "averageSharePct": 86.7`).
Values are **relative** (0 to 100), not absolute search or click counts. Naver does not publish absolute counts in DataLab.

### Endpoints used (official)

Primary, **NAVER API HUB** (headers `X-NCP-APIGW-API-KEY-ID`, `X-NCP-APIGW-API-KEY`, `Content-Type: application/json`):

- `POST https://naverapihub.apigw.ntruss.com/search-trend/v1/search`
- `POST https://naverapihub.apigw.ntruss.com/shopping/v1/categories`
- `POST https://naverapihub.apigw.ntruss.com/shopping/v1/category/keywords`
- `POST https://naverapihub.apigw.ntruss.com/shopping/v1/category/{device|gender|age}`
- `POST https://naverapihub.apigw.ntruss.com/shopping/v1/category/keyword/{device|gender|age}`

Fallback until 2027-06-30, **legacy NAVER Developers** keys (headers `X-Naver-Client-Id`, `X-Naver-Client-Secret`): the same calls under `https://openapi.naver.com/v1/datalab/search` and `https://openapi.naver.com/v1/datalab/shopping/...`.

Getting API HUB keys: Naver Cloud Platform console > Services > Application Services > **NAVER API HUB** > Application > register an application and add **검색어 트렌드** and/or **쇼핑인사이트** > copy the Client ID and Secret from **인증 정보**. API HUB currently lists a free tier for these APIs (up to 30,000 calls); Naver says the free policy may change. A Naver Cloud Platform account (with a payment method) is required.

### API keys (secret inputs)

- All four credential fields are **secret inputs** (`isSecret` in the input schema): Apify stores them encrypted and hides them in the Console and in API responses.
- The actor sends them only as request headers to the official Naver hosts above. They are **never logged, never written** to the dataset or key-value stores, and never put in URLs.
- If a key is exposed, reissue it in the provider console (API HUB: 인증 정보 > 재발급) and update the input.

### Terms notice (read before use)

This actor is a tool **you run with your own NAVER key** for **your own analysis**. You are the API user under the NAVER API terms (developers.naver.com, 이용약관) and the NAVER API HUB / Naver Cloud Platform terms, and you are responsible for how you use the results. In particular, the general conditions do not allow providing the data to third parties, so do not resell or republish the raw trend data. The actor stores nothing between runs; run datasets live only in your Apify account. The developer of this actor does not see, keep or resell your results.

### Limitations

- Values are relative indexes. Anchor re-scaling adds rounding error for very small keywords, so pick an anchor with steady volume.
- Shopping modes need a Naver Shopping category ID (visible as `cat_id` / `catId` in Naver Shopping URLs). Keyword breakdown modes use one category and the first keyword of each group (one call per keyword).
- Breakdown segments are compared within one call only, so they are not re-scaled across categories.
- Data starts in 2016-01 (search) or 2017-08 (shopping).
- If the API HUB free tier ends, calls will be billed to your Naver Cloud account by Naver, not by this actor.

### Pricing

- **Free from 12 November 2026.** Until then the Store shows the earlier pay-per-result price, which is being removed.
- You pay only Apify's normal platform usage for the run (a fraction of a cent for a typical run).
- Naver data is fetched with your own key; Naver does not charge for it on the current free tier.
- Why free: Naver's API terms do not allow earning revenue from the API itself, so this actor is offered at no charge.

### FAQ

**Do I need my own API key?**
Yes. Create an application in the NAVER API HUB (Naver Cloud Platform console), add 검색어 트렌드 and/or 쇼핑인사이트, and paste the Client ID and Secret into the input. The steps are under "Endpoints used" above. Existing NAVER Developers keys also work until 2027-06-30.

**How fresh is the data?**
Every run calls the DataLab API live; nothing is cached. DataLab has data up to yesterday (KST). By default the last unfinished week or month is cut off so the latest value is not a false drop; set `completePeriodsOnly` to `false` to include it.

**Can I schedule it?**
Yes. Use an Apify Schedule (for example weekly with `timeUnit: "week"`) and leave the dates empty, so each run covers the latest 12 months.

**What does a typical run cost?**
It is free (from 12 November 2026); you only pay Apify platform usage, usually well under one cent per run.

**Is this legal, and where does the data come from?**
The data comes from Naver's official DataLab APIs (NAVER API HUB), called with your key under Naver's API terms. No pages are scraped. Read the terms notice above: the raw trend data is for your own analysis and may not be resold or passed to third parties.

# Actor input Schema

## `mode` (type: `string`):

search = Naver search query volume trend (relative). shoppingCategory / shoppingKeyword = Naver Shopping click trends (Shopping Insight). The 'by device / gender / age' modes split one category (each entry in Shopping categories) or each keyword (in the first category) into PC/mobile, male/female or 10s-60s segments, with each segment's share.

## `keywordGroups` (type: `array`):

For search / shoppingKeyword mode. List of groups: \[{"name": "humidifier", "keywords": \["가습기", "가열식가습기"]}]. A plain string is treated as a group with one keyword. More than 5 groups are split into batches and re-scaled with an anchor so all values share one scale. Max 50 groups. For 'Shopping keyword by device/gender/age' each group is one call and only its first keyword is used.

## `shoppingCategories` (type: `array`):

For shoppingCategory mode: \[{"name": "Digital & appliances", "id": "50000003"}]. For shopping keyword modes only the FIRST id is used; category breakdown modes make one call per id. Category IDs are in the Naver Shopping URL (catId=...). Top-level IDs: 50000000 Fashion apparel, 50000001 Fashion accessories, 50000002 Cosmetics & beauty, 50000003 Digital & appliances, 50000004 Furniture & interior, 50000005 Maternity & baby, 50000006 Food, 50000007 Sports & leisure, 50000008 Living & health, 50000009 Leisure & convenience, 50000010 Duty free.

## `anchorKeyword` (type: `string`):

Keyword included in every batch to put batches on a common scale. Pick something with stable, non-zero volume. Defaults to the first group.

## `startDate` (type: `string`):

YYYY-MM-DD. Earliest allowed: 2016-01-01 (search) / 2017-08-01 (shopping). Default: 365 days ago.

## `endDate` (type: `string`):

YYYY-MM-DD. Default: yesterday (KST).

## `completePeriodsOnly` (type: `boolean`):

When no end date is given, stop at the last complete week or month (weeks are Monday-Sunday). A half-finished last week would otherwise look like a sudden drop.

## `timeUnit` (type: `string`):

Granularity of the series.

## `device` (type: `string`):

Filter by device.

## `gender` (type: `string`):

Filter by gender.

## `ages` (type: `array`):

Empty = all ages. Search mode codes: 1=0-12, 2=13-18, 3=19-24, 4=25-29, 5=30-34, 6=35-39, 7=40-44, 8=45-49, 9=50-54, 10=55-59, 11=60+. Shopping mode uses decades: 10,20,30,40,50,60.

## `outputFormat` (type: `string`):

series is best for dashboards and AI agents; points is best for spreadsheets/BI tools.

## `apiProvider` (type: `string`):

NAVER API HUB (Naver Cloud Platform) is the primary path. Legacy NAVER Developers keys keep working only until 2027-06-30 and no new ones are issued.

## `apiHubClientId` (type: `string`):

Naver Cloud Platform console > Services > NAVER API HUB > Application > 인증 정보. Add 검색어 트렌드 and/or 쇼핑인사이트 to the application. Sent only as the X-NCP-APIGW-API-KEY-ID header.

## `apiHubClientSecret` (type: `string`):

Client Secret of the same API HUB application. Sent only as the X-NCP-APIGW-API-KEY header.

## `legacyClientId` (type: `string`):

Optional. An existing developers.naver.com app key. Used only if API HUB keys are missing or rejected, and only until 2027-06-30.

## `legacyClientSecret` (type: `string`):

Optional. Client Secret of the same legacy app.

## Actor input object example

```json
{
  "mode": "search",
  "keywordGroups": [
    {
      "name": "가습기",
      "keywords": [
        "가습기"
      ]
    },
    {
      "name": "공기청정기",
      "keywords": [
        "공기청정기"
      ]
    },
    {
      "name": "전기요",
      "keywords": [
        "전기요",
        "전기매트"
      ]
    }
  ],
  "shoppingCategories": [
    {
      "name": "Digital & appliances",
      "id": "50000003"
    },
    {
      "name": "Cosmetics & beauty",
      "id": "50000002"
    }
  ],
  "anchorKeyword": "",
  "startDate": "",
  "endDate": "",
  "completePeriodsOnly": true,
  "timeUnit": "week",
  "device": "",
  "gender": "",
  "ages": [],
  "outputFormat": "series",
  "apiProvider": "auto"
}
```

# Actor output Schema

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

All result rows in the default dataset.

# 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 = {
    "keywordGroups": [
        {
            "name": "가습기",
            "keywords": [
                "가습기"
            ]
        },
        {
            "name": "공기청정기",
            "keywords": [
                "공기청정기"
            ]
        },
        {
            "name": "전기요",
            "keywords": [
                "전기요",
                "전기매트"
            ]
        }
    ],
    "shoppingCategories": [
        {
            "name": "Digital & appliances",
            "id": "50000003"
        },
        {
            "name": "Cosmetics & beauty",
            "id": "50000002"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("koreadata-lab/naver-shopping-insight-search-trends").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 = {
    "keywordGroups": [
        {
            "name": "가습기",
            "keywords": ["가습기"],
        },
        {
            "name": "공기청정기",
            "keywords": ["공기청정기"],
        },
        {
            "name": "전기요",
            "keywords": [
                "전기요",
                "전기매트",
            ],
        },
    ],
    "shoppingCategories": [
        {
            "name": "Digital & appliances",
            "id": "50000003",
        },
        {
            "name": "Cosmetics & beauty",
            "id": "50000002",
        },
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("koreadata-lab/naver-shopping-insight-search-trends").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 '{
  "keywordGroups": [
    {
      "name": "가습기",
      "keywords": [
        "가습기"
      ]
    },
    {
      "name": "공기청정기",
      "keywords": [
        "공기청정기"
      ]
    },
    {
      "name": "전기요",
      "keywords": [
        "전기요",
        "전기매트"
      ]
    }
  ],
  "shoppingCategories": [
    {
      "name": "Digital & appliances",
      "id": "50000003"
    },
    {
      "name": "Cosmetics & beauty",
      "id": "50000002"
    }
  ]
}' |
apify call koreadata-lab/naver-shopping-insight-search-trends --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,koreadata-lab/naver-shopping-insight-search-trends"
        }
    }
}
```

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/TwA7N7X916RY2EUkm/builds/SwdVcWMFns9Ymm5Mr/openapi.json