# Naver AI Overview API | Korean AEO Monitoring (`johnvc/naver-ai-overview-api`) Actor

Track Naver's AI Overview answers for any query: get the AI-generated overview, its cited sources, and related media as structured JSON. Monitor whether your brand appears in Naver's AI answers. Built for Korean AEO and GEO monitoring. Pay per query, MCP-ready.

- **URL**: https://apify.com/johnvc/naver-ai-overview-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** AI, SEO tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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 AI Overview API | Korean AEO Monitoring | 네이버 AI 브리핑 API

Track Naver's AI Overview answers for any query and get the AI-generated overview, its cited sources, and related media as structured JSON. Naver is South Korea's largest search engine, and its AI answers increasingly shape what Korean users see first. This API lets you monitor whether your brand, product, or topic appears in those answers, and which sources Naver cites.

This is a brand-monitoring and answer-engine-optimization (AEO) tool, not a generic scraper. Send one query or many, and get one clean row per query: the full answer as markdown, the structured text blocks, the cited references, and related media.

**한국어:** 네이버 AI 브리핑(AI 오버뷰) 답변을 검색어별로 추적하여, AI가 생성한 요약과 인용 출처, 관련 미디어를 구조화된 JSON으로 받아보세요. 네이버는 대한민국 최대 검색엔진이며, 그 AI 답변은 한국 사용자가 가장 먼저 보는 정보를 점점 더 좌우합니다. 이 API로 우리 브랜드, 제품, 주제가 해당 답변에 노출되는지, 그리고 네이버가 어떤 출처를 인용하는지 모니터링할 수 있습니다. 단순 스크레이퍼가 아니라 브랜드 모니터링과 답변엔진최적화(AEO)를 위한 도구로, 검색어 하나 또는 여러 개를 보내면 검색어당 한 줄의 깔끔한 결과(마크다운 전체 답변, 구조화된 텍스트 블록, 인용 출처, 관련 미디어)를 돌려줍니다.

### What you get | 제공 데이터

One row per query:

- `ai_overview_present`: whether Naver showed an AI Overview
- `markdown`: the full AI Overview answer as markdown
- `text_blocks`: the structured content blocks (paragraphs, lists) with reference indexes
- `references`: the cited sources, each with title, link, snippet, and source
- `media`: related videos and images, each with title, link, platform, and thumbnail
- `related_questions`: follow-up questions Naver associates with the answer

**한국어:** 검색어당 한 행을 반환합니다.

- `ai_overview_present`: 네이버가 AI 브리핑을 표시했는지 여부
- `markdown`: AI 브리핑 전체 답변 (마크다운 형식)
- `text_blocks`: 구조화된 콘텐츠 블록 (단락, 목록)과 참조 인덱스
- `references`: 인용된 출처 (제목, 링크, 스니펫, 출처명)
- `media`: 관련 동영상 및 이미지 (제목, 링크, 플랫폼, 썸네일)
- `related_questions`: 네이버가 답변과 연관짓는 후속 질문

### Use cases | 활용 사례

- Monitor whether your brand or product appears in Naver's AI answers (Korean AEO)
- Track which sources Naver cites for your category, and how that shifts over time
- Audit competitor visibility in Naver's AI Overviews across a list of queries
- Feed an AI agent the current Naver AI answer for a Korean-market topic in one call
- Build an AEO dashboard that re-runs key queries on a schedule

**한국어:**

- 네이버 AI 답변에 우리 브랜드나 제품이 노출되는지 모니터링 (한국형 AEO)
- 네이버가 우리 카테고리에서 어떤 출처를 인용하는지, 시간에 따라 어떻게 변하는지 추적
- 여러 검색어에 걸쳐 경쟁사의 네이버 AI 브리핑 노출 현황 점검
- 한국 시장 주제에 대한 현재 네이버 AI 답변을 한 번의 호출로 AI 에이전트에 전달
- 핵심 검색어를 주기적으로 재실행하는 AEO 대시보드 구축

### Input | 입력

| Field | Type | Description |
|-------|------|-------------|
| `query` | string | A single query, in Korean or any language, e.g. `당뇨병 증상`. Provide this, `queries`, or both. |
| `queries` | array of strings | A batch of queries to check in one run. Merged with `query` and de-duplicated. |

**한국어:**

| 필드 | 유형 | 설명 |
|-------|------|-------------|
| `query` | 문자열 | 단일 검색어. 한국어 또는 다른 언어 모두 가능, 예: `당뇨병 증상`. 이 값, `queries`, 또는 둘 다 입력하세요. |
| `queries` | 문자열 배열 | 한 번의 실행에서 확인할 검색어 묶음. `query`와 병합되고 중복은 제거됩니다. |

#### Example input | 입력 예시

```json
{
  "queries": ["당뇨병 증상", "전기차 보조금"]
}
````

### Sample output | 출력 예시

```json
{
  "result_type": "ai_overview",
  "query": "당뇨병 증상",
  "ai_overview_present": true,
  "markdown": "당뇨병의 주요 증상은 ...",
  "text_blocks": [
    { "type": "paragraph", "snippet": "당뇨병의 주요 증상은 ...", "reference_indexes": [0, 1] }
  ],
  "references": [
    { "index": 0, "title": "당뇨병 - 질병관리청", "link": "https://example.go.kr/...", "source": "질병관리청" }
  ],
  "media": [
    { "title": "당뇨병 증상 설명", "platform": "video", "link": "https://example.com/...", "thumbnail": "https://..." }
  ]
}
```

**한국어:** 각 검색어는 위와 같은 한 행으로 반환됩니다. `markdown`에는 전체 답변이, `references`에는 네이버가 인용한 출처가, `media`에는 관련 동영상과 이미지가 담깁니다. AI 브리핑이 없으면 `ai_overview_present`는 `false`가 되고 짧은 `note`가 함께 제공됩니다.

### Pricing | 요금

Pay per query: a flat **$0.012 per query** resolved, whether or not an AI Overview is shown (the lookup is performed either way). No setup fee, no per-run fee. Batch many queries in one run to monitor a whole topic set.

**한국어:** 검색어당 과금: 해결된 검색어당 정액 **$0.012**이며, AI 브리핑 표시 여부와 관계없이 부과됩니다(조회는 어느 경우든 수행되기 때문입니다). 설정 비용이나 실행당 비용은 없습니다. 한 번의 실행에 여러 검색어를 묶어 주제 세트 전체를 모니터링하세요.

### How to get started | 시작하기

1. Open [Naver AI Overview API on the Apify Store](https://apify.com/johnvc/naver-ai-overview-api?fpr=9n7kx3).
2. Enter a `query` (or a `queries` list of brand or topic terms).
3. Run the Actor and read the AI Overview, its sources, and media from the dataset.
4. Export as JSON, CSV, or Excel, or pull it from the API. Schedule it to track changes.

Prefer code? See the [Naver AI Overview API example repo](https://github.com/johnisanerd/Apify-Naver-AI-Overview-API) for a Python quick-start and MCP setup walkthroughs.

**한국어:**

1. [Apify 스토어의 Naver AI Overview API](https://apify.com/johnvc/naver-ai-overview-api?fpr=9n7kx3)를 엽니다.
2. `query`(또는 브랜드나 주제 검색어 목록인 `queries`)를 입력합니다.
3. Actor를 실행하고 데이터셋에서 AI 브리핑, 출처, 미디어를 확인합니다.
4. JSON, CSV, Excel로 내보내거나 API로 가져옵니다. 변화를 추적하려면 예약 실행을 설정하세요.

코드로 사용하고 싶으신가요? [Naver AI Overview API 예제 저장소](https://github.com/johnisanerd/Apify-Naver-AI-Overview-API)에서 파이썬 빠른 시작과 MCP 설정 가이드를 확인하세요.

### Run from the API | API로 실행하기

```bash
curl -X POST "https://api.apify.com/v2/acts/johnvc~naver-ai-overview-api/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query":"당뇨병 증상"}'
```

**한국어:** 위 `curl` 명령에서 `YOUR_APIFY_TOKEN`을 본인의 Apify API 토큰으로 바꾸면, 실행이 끝난 뒤 데이터셋 결과를 곧바로 받아볼 수 있습니다.

### 🔌 Use this API from Claude (MCP) | Claude에서 사용하기 (MCP)

**Model Context Protocol (MCP)** lets an AI assistant call external tools the same way it calls built-in features. With the Apify MCP server, your agent can run this Actor, read the dataset, and summarize whether your brand appears in **네이버 AI 브리핑** (Naver AI Overview) without you writing curl or Python first.

This Actor is MCP-ready. Connect through Apify's hosted server and load only the tools you need for Naver monitoring.

**한국어:** \*\*모델 컨텍스트 프로토콜(MCP)\*\*은 AI 어시스턴트가 내장 기능을 호출하듯 외부 도구를 호출하도록 해줍니다. Apify MCP 서버를 사용하면, 직접 curl이나 파이썬을 작성하지 않고도 에이전트가 이 Actor를 실행하고 데이터셋을 읽어 우리 브랜드가 **네이버 AI 브리핑**에 노출되는지 요약해 줍니다. 이 Actor는 MCP를 지원하므로, Apify 호스팅 서버에 연결한 뒤 네이버 모니터링에 필요한 도구만 불러오면 됩니다.

#### What you need first | 먼저 필요한 것

1. An [Apify account](https://console.apify.com/sign-up) (free tier is enough to try a few queries).
2. An **Apify API token** from [API & Integrations](https://console.apify.com/account/integrations) in Apify Console. Keep it private; the agent uses it to run Actors on your behalf.
3. An **MCP-capable client** such as [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), Claude on the web, Cursor, or ChatGPT (with MCP support).

**한국어:**

1. [Apify 계정](https://console.apify.com/sign-up) (무료 등급으로도 몇 개의 검색어를 시험해볼 수 있습니다).
2. Apify Console의 [API & Integrations](https://console.apify.com/account/integrations)에서 발급하는 **Apify API 토큰**. 비공개로 보관하세요. 에이전트가 사용자를 대신해 Actor를 실행할 때 사용합니다.
3. **MCP를 지원하는 클라이언트** (예: [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (무료 체험), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (무료 체험), 웹 버전 Claude, Cursor, 또는 MCP를 지원하는 ChatGPT).

#### Actor-specific MCP URL | 이 Actor 전용 MCP URL

Use this URL so the server loads Actor discovery, Apify docs, and **this** Actor as a callable tool (not every scraper in the Store):

```
https://mcp.apify.com/?tools=actors,docs,johnvc/naver-ai-overview-api
```

You can also build the same URL visually at [mcp.apify.com](https://mcp.apify.com/) and copy the config into your client.

**한국어:** 아래 URL을 사용하면 서버가 Actor 검색, Apify 문서, 그리고 **이** Actor만 호출 가능한 도구로 불러옵니다(스토어의 모든 스크레이퍼가 아니라). [mcp.apify.com](https://mcp.apify.com/)에서 같은 URL을 시각적으로 만들어 클라이언트 설정에 붙여 넣을 수도 있습니다.

#### MCP setup, step by step | MCP 설정 단계별 안내

**Step 1 - Choose how to sign in | 1단계 - 로그인 방식 선택**

- **OAuth (recommended):** Point your client at `https://mcp.apify.com` (or the Actor-specific URL above). On first connect, your browser opens so you can sign in to Apify and approve access. No token pasted into chat.
- **Bearer token:** If your client needs a static config, add `Authorization: Bearer YOUR_APIFY_TOKEN` in the MCP server headers. Replace `YOUR_APIFY_TOKEN` with the token from Apify Console.

**한국어:**

- **OAuth (권장):** 클라이언트를 `https://mcp.apify.com`(또는 위의 Actor 전용 URL)로 연결합니다. 처음 연결할 때 브라우저가 열려 Apify에 로그인하고 접근을 승인합니다. 채팅에 토큰을 붙여 넣을 필요가 없습니다.
- **Bearer 토큰:** 정적 설정이 필요한 클라이언트라면 MCP 서버 헤더에 `Authorization: Bearer YOUR_APIFY_TOKEN`을 추가하세요. `YOUR_APIFY_TOKEN`은 Apify Console의 토큰으로 바꿉니다.

**Step 2 - Add the server in your client | 2단계 - 클라이언트에 서버 추가**

Open your client's MCP settings (see screenshots below) and add the Apify server URL from the previous section. Restart or reload MCP if the client asks you to.

**한국어:** 클라이언트의 MCP 설정(아래 스크린샷 참고)을 열고 앞 단계의 Apify 서버 URL을 추가합니다. 클라이언트가 요청하면 MCP를 재시작하거나 다시 불러오세요.

**Step 3 - Confirm the tool is available | 3단계 - 도구 사용 가능 여부 확인**

In a new chat, ask the agent to list MCP tools or to "fetch details for `johnvc/naver-ai-overview-api`." You should see a way to run the Naver AI Overview Actor with a `query` or `queries` input.

**한국어:** 새 대화에서 에이전트에게 MCP 도구 목록을 보여달라고 하거나 "`johnvc/naver-ai-overview-api`의 상세 정보를 가져와줘"라고 요청하세요. `query` 또는 `queries` 입력으로 Naver AI Overview Actor를 실행하는 방법이 보여야 합니다.

**Step 4 - Run a Korean AEO check | 4단계 - 한국형 AEO 점검 실행**

Paste a prompt in English or Korean. The Actor accepts Korean queries such as `당뇨병 증상` or `우리 브랜드명 + 제품 카테고리`.

Example prompts:

- English: "Using the Naver AI Overview API, check whether our brand is cited in Naver's AI answer for these queries: `전기차 보조금`, `당뇨병 증상`. Summarize `ai_overview_present`, the answer excerpt, and which `references` mention us."
- Korean: "Apify의 `johnvc/naver-ai-overview-api`로 다음 검색어의 **네이버 AI 브리핑**을 조회해줘: `전기차 보조금`, `우리브랜드 대체제 추천`. 각 쿼리마다 AI 답변이 있는지, 우리 브랜드/도메인이 `references`에 나오는지 표로 정리해줘."

**한국어:** 영어 또는 한국어로 프롬프트를 입력하세요. Actor는 `당뇨병 증상`이나 `우리 브랜드명 + 제품 카테고리` 같은 한국어 검색어를 그대로 받습니다. 위의 한국어 예시 프롬프트를 그대로 사용하면 됩니다.

**Step 5 - Read the results | 5단계 - 결과 확인**

The agent returns structured rows: `markdown` (full answer text), `references` (cited sources), `media`, and `ai_overview_present`. Use that for AEO reporting or follow-up questions in the same thread.

**한국어:** 에이전트는 `markdown`(전체 답변 텍스트), `references`(인용 출처), `media`, `ai_overview_present`로 구성된 구조화된 행을 반환합니다. 이를 AEO 보고서에 활용하거나 같은 대화에서 추가 질문에 사용하세요.

Video walkthrough: [YouTube - Apify MCP setup](https://www.youtube.com/watch?v=jREWahDGhJM)

Full platform docs: [Apify MCP integration](https://docs.apify.com/platform/integrations/mcp)

**한국어:** 영상 안내: [YouTube - Apify MCP 설정](https://www.youtube.com/watch?v=jREWahDGhJM) · 전체 플랫폼 문서: [Apify MCP 연동](https://docs.apify.com/platform/integrations/mcp)

#### Visual setup by client | 클라이언트별 설정 화면

Screenshots show where to paste the server URL in each app (more assets: [ApifyPublicData on GitHub](https://github.com/johnisanerd/ApifyPublicData)).

**한국어:** 아래 스크린샷은 각 앱에서 서버 URL을 붙여 넣는 위치를 보여줍니다 (추가 자료: [GitHub의 ApifyPublicData](https://github.com/johnisanerd/ApifyPublicData)).

**Claude Cowork Desktop**

![Install in Claude Cowork Desktop](https://raw.githubusercontent.com/johnisanerd/ApifyPublicData/main/assets/guides/install_mcp_into_claude_desktop.png)

**Claude Code**

![Install in Claude Code](https://raw.githubusercontent.com/johnisanerd/ApifyPublicData/main/assets/guides/install_mcp_into_claude_code.png)

**Claude (website)**

![Install in Claude website](https://raw.githubusercontent.com/johnisanerd/ApifyPublicData/main/assets/guides/install_mcp_into_claude_ai.png)

**Cursor**

![Install in Cursor](https://raw.githubusercontent.com/johnisanerd/ApifyPublicData/main/assets/guides/install_mcp_into_cursor.png)

**ChatGPT**

![Install in ChatGPT](https://raw.githubusercontent.com/johnisanerd/ApifyPublicData/main/assets/guides/install_mcp_into_ChatGPT.png)

### FAQ | 자주 묻는 질문

**What is an AI Overview?** It is the AI-generated answer Naver shows at the top of results for many informational queries, with cited sources. This API returns that answer and its sources as structured data.

**Do I get charged if no AI Overview is shown?** Yes, a flat per-query fee, because the lookup runs either way. The row will have `ai_overview_present: false` and a short `note`.

**Which queries return an AI Overview?** Informational and question-style queries (symptoms, how-to, comparisons, definitions) are most likely. Navigational or very niche queries often have none.

**Can I monitor many terms at once?** Yes. Pass a `queries` list; each is checked independently and returned as its own row.

**Is the answer in Korean?** Yes, Naver answers in Korean. The `markdown` field gives you the full answer text to translate or analyze.

**한국어:**

**AI 브리핑(AI 오버뷰)이란 무엇인가요?** 네이버가 많은 정보성 검색어에 대해 결과 상단에 보여주는, 출처가 인용된 AI 생성 답변입니다. 이 API는 그 답변과 출처를 구조화된 데이터로 반환합니다.

**AI 브리핑이 표시되지 않아도 과금되나요?** 네, 조회는 어느 경우든 수행되므로 검색어당 정액 요금이 부과됩니다. 해당 행은 `ai_overview_present: false`와 짧은 `note`를 갖습니다.

**어떤 검색어에서 AI 브리핑이 나오나요?** 증상, 방법, 비교, 정의 같은 정보성·질문형 검색어에서 가장 자주 나옵니다. 단순 이동형(내비게이션) 검색어나 매우 좁은 검색어는 없는 경우가 많습니다.

**여러 검색어를 한 번에 모니터링할 수 있나요?** 네. `queries` 목록을 전달하면 각 검색어가 독립적으로 조회되어 각각의 행으로 반환됩니다.

**답변은 한국어로 나오나요?** 네, 네이버는 한국어로 답합니다. `markdown` 필드에 전체 답변 텍스트가 담기므로 번역하거나 분석할 수 있습니다.

Last Updated: 2026.06.02

# Actor input Schema

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

Enter a single query, in Korean or any language, to fetch the Naver AI Overview for, for example '당뇨병 증상' (diabetes symptoms). Provide this, `queries`, or both. AI Overviews appear most often for informational, question-style searches. 네이버 AI 브리핑을 조회할 검색어 하나를 입력하세요(한국어 또는 다른 언어 가능). 정보성·질문형 검색어에서 AI 브리핑이 가장 자주 나타납니다.

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

Provide a list of queries to fetch AI Overviews for in one run. Merged with `query` and de-duplicated. Use this for batch brand-monitoring lookups. 한 번의 실행에서 조회할 검색어 목록입니다. `query`와 병합되고 중복은 제거됩니다. 대량 브랜드 모니터링에 사용하세요.

## Actor input object example

```json
{
  "query": "당뇨병 증상"
}
```

# Actor output Schema

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

All AI Overview rows stored in the default dataset, one item per query. 기본 데이터셋에 저장된 모든 AI 브리핑 행이며, 검색어당 한 항목입니다.

# 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 = {
    "query": "당뇨병 증상"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/naver-ai-overview-api").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 = { "query": "당뇨병 증상" }

# Run the Actor and wait for it to finish
run = client.actor("johnvc/naver-ai-overview-api").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 '{
  "query": "당뇨병 증상"
}' |
apify call johnvc/naver-ai-overview-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=johnvc/naver-ai-overview-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver AI Overview API | Korean AEO Monitoring",
        "description": "Track Naver's AI Overview answers for any query: get the AI-generated overview, its cited sources, and related media as structured JSON. Monitor whether your brand appears in Naver's AI answers. Built for Korean AEO and GEO monitoring. Pay per query, MCP-ready.",
        "version": "0.0",
        "x-build-id": "atGW7LoHgQ35A9sQU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/johnvc~naver-ai-overview-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-johnvc-naver-ai-overview-api",
                "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/johnvc~naver-ai-overview-api/runs": {
            "post": {
                "operationId": "runs-sync-johnvc-naver-ai-overview-api",
                "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/johnvc~naver-ai-overview-api/run-sync": {
            "post": {
                "operationId": "run-sync-johnvc-naver-ai-overview-api",
                "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",
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Enter a single query, in Korean or any language, to fetch the Naver AI Overview for, for example '당뇨병 증상' (diabetes symptoms). Provide this, `queries`, or both. AI Overviews appear most often for informational, question-style searches. 네이버 AI 브리핑을 조회할 검색어 하나를 입력하세요(한국어 또는 다른 언어 가능). 정보성·질문형 검색어에서 AI 브리핑이 가장 자주 나타납니다."
                    },
                    "queries": {
                        "title": "Search Queries",
                        "type": "array",
                        "description": "Provide a list of queries to fetch AI Overviews for in one run. Merged with `query` and de-duplicated. Use this for batch brand-monitoring lookups. 한 번의 실행에서 조회할 검색어 목록입니다. `query`와 병합되고 중복은 제거됩니다. 대량 브랜드 모니터링에 사용하세요.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
