# Naver Search Scraper (통합검색) (`hgservices/naver-search-scraper`) Actor

Scrape Naver integrated search (통합검색) results as ranked blocks — 파워링크 ads, 블로그, 카페, 지식iN, 뉴스, 플레이스, 쇼핑, 웹사이트 and more — for any keyword. One dataset item per SERP page.

- **URL**: https://apify.com/hgservices/naver-search-scraper.md
- **Developed by:** [Harish Garg](https://apify.com/hgservices) (community)
- **Categories:** SEO tools, AI, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 scraped search result pages

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Search Scraper (통합검색)

**Scrape Naver search results** — the way Koreans actually see them. Unlike Google, a
Naver **통합검색 (integrated search)** page is not a list of ten blue links; it's a **blended
feed of ranked blocks**: **파워링크** ads, **블로그**, **카페**, **지식iN**, **뉴스**, **플레이스**,
**네이버쇼핑**, **웹사이트** and more. This Actor fetches those pages for any keyword and returns
**one structured record per SERP page, with every block in its real ranked order** — so you
can see not just *what* ranks on [Naver](https://search.naver.com), but *which kind of Naver
content* wins each query.

Built to run on the **Apify platform**: schedule runs, call it from the API, export to
JSON/CSV/Excel, and rely on rotating **Korean residential proxies** so Naver serves you the
same results a real user in Korea gets.

### Why use Naver Search Scraper?

Naver owns ~55–60% of Korean search. Winning in Korea means understanding Naver's *blended*
SERP, not Google's. Use this Actor to:

- **Track keyword rankings** across 블로그 / 카페 / 지식iN / 뉴스 / 플레이스 — per block, per position.
- **Monitor 파워링크 ads** — who's bidding on your keywords and what copy they run.
- **Do Korean SEO & content research** — which content type Naver surfaces for a query (blog vs. café vs. shopping) tells you where to publish.
- **Watch brand & competitor mentions** across Naver's UGC ecosystem.
- **Feed pipelines** — clean JSON for dashboards, alerts, or LLM/RAG ingestion.

### How to use Naver Search Scraper

1. Open the Actor and go to the **Input** tab.
2. Enter one or more **search terms** (Korean works best), one per line — e.g. `강남 맛집`.
3. Pick a **search surface** — `통합검색 (integrated)` is the default blended page.
4. Set **Max pages per query** (you're billed per page scraped).
5. Click **Start**. When it finishes, open the **Output** tab or **Export** to JSON/CSV/Excel.

That's it. Korean residential proxying, throttling, and retries are handled for you.

### Input

| Field | Type | Description |
|---|---|---|
| `queries` | array | Search terms, one per line. Korean recommended. **Required.** |
| `searchType` | string | `integrated` (통합검색, default), or a single vertical: `web`, `blog`, `cafe`, `kin`, `news`, `shopping`, `image`, `video`, `influencer`. |
| `maxPagesPerQuery` | integer | Result pages per term (~10 results/page). Default `1`. |
| `sortBy` | string | `relevance`, `date_desc`, `date_asc`. |
| `dateRange` | string | `''` (any), `1d`, `1w`, `1m`, `6m`, `1y`. |
| `includeAds` | boolean | Include 파워링크 / 비즈사이트 ad blocks. Default `true`. |
| `blocks` | array | For 통합검색, keep only these block types (empty = all). |
| `mobileResults` | boolean | Scrape the mobile layout instead of desktop. |
| `saveHtml` | boolean | Store each page's raw HTML in the key-value store. |
| `useOpenApi` | boolean | Also query Naver's official Open API and attach as `openApiResults` (needs your own credentials). |
| `naverClientId` / `naverClientSecret` | string | Your Naver Open API credentials (only for enrichment). |
| `language` | string | Accept-Language hint. `ko` recommended. |
| `maxConcurrency` | integer | Parallel page fetches (1–10). |

#### Example input

```json
{
    "queries": ["강남 맛집", "삼겹살"],
    "searchType": "integrated",
    "maxPagesPerQuery": 2,
    "sortBy": "relevance",
    "includeAds": true
}
````

### Output

**One dataset item per SERP page.** Each item gives you the same results in two shapes, so
you can pick whichever fits your workflow:

- **`results`** — a **flat list**, one entry per result, each tagged with its `blockType`,
  `blockPosition`, and page-wide `rank`. This is the Google-style view: just map over it.
- **`blocks`** — the **ranked blocks** exactly as Naver stacks them (파워링크 · 블로그 · 카페 ·
  지식iN · 뉴스 · 플레이스 · 웹사이트 …), preserving the real on-page layout.

```json
{
    "searchQuery": {
        "term": "강남 맛집",
        "url": "https://search.naver.com/search.naver?query=%EA%B0%95%EB%82%A8+%EB%A7%9B%EC%A7%91&where=nexearch&start=1",
        "where": "nexearch",
        "searchType": "integrated",
        "device": "DESKTOP",
        "page": 1,
        "sortBy": "relevance",
        "dateRange": ""
    },
    "resultsTotal": null,
    "hasNextPage": true,
    "resultCount": 42,
    "results": [
        {
            "rank": 1,
            "blockType": "place",
            "blockPosition": 1,
            "rankInBlock": 1,
            "type": "place",
            "title": "육싸롱 이도점",
            "url": "https://map.naver.com/p/entry/place/2073228508",
            "category": "한식",
            "address": "제주 제주시 아라이동",
            "placeId": "2073228508"
        },
        {
            "rank": 12,
            "blockType": "blog",
            "blockPosition": 2,
            "rankInBlock": 1,
            "type": "blog",
            "title": "강남역 맛집 베스트 10",
            "url": "https://blog.naver.com/foodie/223...",
            "description": "직접 다녀온 강남 맛집을 정리했습니다",
            "date": "3일 전",
            "authorOrChannel": "푸디"
        }
    ],
    "blocks": [
        {
            "type": "place",
            "label": "플레이스",
            "position": 1,
            "items": [
                { "type": "place", "title": "육싸롱 이도점", "url": "https://map.naver.com/p/entry/place/2073228508", "category": "한식", "address": "제주 제주시 아라이동", "placeId": "2073228508" }
            ]
        }
    ]
}
```

You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**. The
**Results (flat)** dataset view gives one row per result for spreadsheet / no-code users;
**Blocks (flattened)** gives one row per block if you care about the page layout.

#### Data fields

| Field | Description |
|---|---|
| `searchQuery.term` / `url` | The search term and the exact Naver URL scraped. |
| `searchQuery.searchType` / `where` | Which surface (통합검색 / vertical). |
| `searchQuery.page` | Page number within the query. |
| `resultsTotal` | Naver's reported total, when shown (often `null` on 통합검색). |
| `hasNextPage` | Whether a further page exists (`null` when Naver shows no pager). |
| `resultCount` | Number of results extracted on this page. |
| `results[]` | **Flat** list: `rank`, `blockType`, `blockPosition`, `type`, `title`, `url`, plus per-type extras below. |
| `blocks[].type` / `position` | Block type (`powerlink`, `blog`, `cafe`, `kin`, `news`, `place`, `shopping`, `influencer`, `image`, `video`, `web`) and its rank on the page. |
| `blocks[].items[]` | Results in the block (same objects as `results[]`, minus the block-context fields). |
| item: `title` / `url` / `description` | Clean title, destination URL, and snippet (when present). |
| item: `date` | Posting date / meta ("3일 전", "30.9만 인용"), when shown. |
| item: `displayedUrl` | Visible URL breadcrumb or ad domain — useful when `url` is an ad redirector. |
| item: `category` / `address` / `badges` | **플레이스** only: business category, address, and status chips (예약/쿠폰 …). |
| item: `authorOrChannel` / `press` | Blog/café author or news outlet, when shown. |
| `openApiResults` | (Optional) clean Open API items, when enrichment is enabled. |
| `htmlSnapshotKey` | (Optional) key-value store key for the saved raw HTML. |

### Pricing / How much does it cost to scrape Naver?

This Actor uses **pay-per-event** pricing, mirroring Apify's Google Search Scraper: you pay
per **SERP page scraped** — not per result — so cost is predictable regardless of how densely
a page is packed. Optional Naver Open API enrichment is charged per API call.

Naver runs are inherently a little pricier than Google ones because they require **Korean
residential proxies** (Naver blocks datacenter and foreign IPs). To control cost, keep
`maxPagesPerQuery` low and scrape only the verticals you need via `searchType` / `blocks`.

### Tips & advanced options

- **Korean queries return the best results** — Naver is a Korean-first engine.
- **Scope tightly**: use `searchType` for a single vertical, or `blocks` to keep only the
  block types you care about, to cut noise and cost.
- **Time-sensitive research**: combine `sortBy: date_desc` with `dateRange` for fresh results.
- **Debugging extraction**: turn on `saveHtml` to inspect the exact HTML behind a record.

### FAQ, disclaimers & support

- **Is scraping Naver legal?** This Actor collects **publicly available** search results.
  You are responsible for using the data in compliance with Naver's Terms of Service, robots
  directives, and applicable laws (including personal-data and copyright law). Do not use it to
  infringe rights or overload Naver's servers.
- **Why blocks instead of "organic results"?** Because that's what a Naver page *is*. Forcing
  Google's organic-links model onto Naver would misrepresent the results. See the block model above.
- **Results look incomplete for a query.** Naver's markup changes often and varies by keyword,
  device, and region. Enable `saveHtml` and open an issue with the snapshot so extraction can be tuned.
- **Support / feature requests**: use the **Issues** tab on the Actor's page.

# Actor input Schema

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

What you'd type into the Naver search bar. One term per line — e.g. 삼겹살, 강남 맛집, 아이폰 15. Korean terms match best. Each term is searched separately.

## `searchType` (type: `string`):

Which Naver search to scrape. '통합검색 (integrated)' is the blended results page most users see and is the default. The others scrape a single vertical's ranked list.

## `maxPagesPerQuery` (type: `integer`):

How many result pages to scrape for each term (~10 results/page for most verticals). You are billed per SERP page scraped.

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

Result ordering. Naver's default is relevance; date sorting applies where Naver supports it (blog, café, news).

## `dateRange` (type: `string`):

Restrict results to a recent time window (where Naver supports it). Leave as 'Any time' for no filter.

## `includeAds` (type: `boolean`):

Capture paid 파워링크 / 비즈사이트 ad blocks alongside organic results. Turn off to keep only organic blocks.

## `blocks` (type: `array`):

For 통합검색, restrict output to specific block types (leave empty to keep every block in ranked order). Values: powerlink, influencer, blog, cafe, kin, news, place, shopping, image, video, web.

## `mobileResults` (type: `boolean`):

Scrape the mobile layout (m.search.naver.com) instead of desktop. Mobile and desktop SERPs differ in blocks and ordering.

## `saveHtml` (type: `boolean`):

Store each SERP page's raw HTML in the key-value store (referenced by 'htmlSnapshotKey' in the output). Useful for debugging or tuning extraction.

## `useOpenApi` (type: `boolean`):

Additionally query Naver's official Search Open API (clean per-vertical JSON) and attach it as 'openApiResults'. Requires your own Naver developer credentials below. This is optional enrichment — the scraped SERP is always the primary output.

## `naverClientId` (type: `string`):

Your Naver Open API Client ID (X-Naver-Client-Id). Only used when 'Enrich via Naver Open API' is on.

## `naverClientSecret` (type: `string`):

Your Naver Open API Client Secret (X-Naver-Client-Secret). Only used when 'Enrich via Naver Open API' is on.

## `language` (type: `string`):

Accept-Language hint sent to Naver. Korean is strongly recommended — Naver serves Korean results regardless, and non-Korean hints can trigger stricter bot checks.

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

Maximum SERP pages fetched in parallel. Naver rate-limits aggressively; the Actor also self-throttles, so keep this modest.

## Actor input object example

```json
{
  "queries": [
    "강남 맛집",
    "삼겹살"
  ],
  "searchType": "integrated",
  "maxPagesPerQuery": 1,
  "sortBy": "relevance",
  "dateRange": "",
  "includeAds": true,
  "blocks": [
    "blog",
    "cafe",
    "kin"
  ],
  "mobileResults": false,
  "saveHtml": false,
  "useOpenApi": false,
  "language": "ko",
  "maxConcurrency": 5
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `htmlSnapshots` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "강남 맛집"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/naver-search-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 = { "queries": ["강남 맛집"] }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/naver-search-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 '{
  "queries": [
    "강남 맛집"
  ]
}' |
apify call hgservices/naver-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver Search Scraper (통합검색)",
        "description": "Scrape Naver integrated search (통합검색) results as ranked blocks — 파워링크 ads, 블로그, 카페, 지식iN, 뉴스, 플레이스, 쇼핑, 웹사이트 and more — for any keyword. One dataset item per SERP page.",
        "version": "0.1",
        "x-build-id": "u9OV7AGYcsVm5c25G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hgservices~naver-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hgservices-naver-search-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/hgservices~naver-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-hgservices-naver-search-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/hgservices~naver-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-hgservices-naver-search-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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "🔍 Search terms",
                        "type": "array",
                        "description": "What you'd type into the Naver search bar. One term per line — e.g. 삼겹살, 강남 맛집, 아이폰 15. Korean terms match best. Each term is searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchType": {
                        "title": "Search surface",
                        "enum": [
                            "integrated",
                            "web",
                            "blog",
                            "cafe",
                            "kin",
                            "news",
                            "shopping",
                            "image",
                            "video",
                            "influencer"
                        ],
                        "type": "string",
                        "description": "Which Naver search to scrape. '통합검색 (integrated)' is the blended results page most users see and is the default. The others scrape a single vertical's ranked list.",
                        "default": "integrated"
                    },
                    "maxPagesPerQuery": {
                        "title": "📄 Max pages per query",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How many result pages to scrape for each term (~10 results/page for most verticals). You are billed per SERP page scraped.",
                        "default": 1
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date_desc",
                            "date_asc"
                        ],
                        "type": "string",
                        "description": "Result ordering. Naver's default is relevance; date sorting applies where Naver supports it (blog, café, news).",
                        "default": "relevance"
                    },
                    "dateRange": {
                        "title": "📅 Date range",
                        "enum": [
                            "",
                            "1d",
                            "1w",
                            "1m",
                            "6m",
                            "1y"
                        ],
                        "type": "string",
                        "description": "Restrict results to a recent time window (where Naver supports it). Leave as 'Any time' for no filter.",
                        "default": ""
                    },
                    "includeAds": {
                        "title": "Include ads (파워링크)",
                        "type": "boolean",
                        "description": "Capture paid 파워링크 / 비즈사이트 ad blocks alongside organic results. Turn off to keep only organic blocks.",
                        "default": true
                    },
                    "blocks": {
                        "title": "Keep only these blocks",
                        "type": "array",
                        "description": "For 통합검색, restrict output to specific block types (leave empty to keep every block in ranked order). Values: powerlink, influencer, blog, cafe, kin, news, place, shopping, image, video, web.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mobileResults": {
                        "title": "Mobile results",
                        "type": "boolean",
                        "description": "Scrape the mobile layout (m.search.naver.com) instead of desktop. Mobile and desktop SERPs differ in blocks and ordering.",
                        "default": false
                    },
                    "saveHtml": {
                        "title": "Save raw HTML",
                        "type": "boolean",
                        "description": "Store each SERP page's raw HTML in the key-value store (referenced by 'htmlSnapshotKey' in the output). Useful for debugging or tuning extraction.",
                        "default": false
                    },
                    "useOpenApi": {
                        "title": "Enrich via Naver Open API",
                        "type": "boolean",
                        "description": "Additionally query Naver's official Search Open API (clean per-vertical JSON) and attach it as 'openApiResults'. Requires your own Naver developer credentials below. This is optional enrichment — the scraped SERP is always the primary output.",
                        "default": false
                    },
                    "naverClientId": {
                        "title": "Naver Client ID",
                        "type": "string",
                        "description": "Your Naver Open API Client ID (X-Naver-Client-Id). Only used when 'Enrich via Naver Open API' is on."
                    },
                    "naverClientSecret": {
                        "title": "Naver Client Secret",
                        "type": "string",
                        "description": "Your Naver Open API Client Secret (X-Naver-Client-Secret). Only used when 'Enrich via Naver Open API' is on."
                    },
                    "language": {
                        "title": "🌍 Language",
                        "enum": [
                            "ko",
                            "en"
                        ],
                        "type": "string",
                        "description": "Accept-Language hint sent to Naver. Korean is strongly recommended — Naver serves Korean results regardless, and non-Korean hints can trigger stricter bot checks.",
                        "default": "ko"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum SERP pages fetched in parallel. Naver rate-limits aggressively; the Actor also self-throttles, so keep this modest.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
