# Naver Café Scraper (네이버 카페) (`hgservices/naver-cafe-scraper`) Actor

Scrape public Naver Café posts, comments and engagement stats — authors, dates, views and likes — from Korea's biggest community platform. Filter by café, board, or keyword.

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

## Pricing

from $1.00 / 1,000 article scrapeds

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 Café Scraper (네이버 카페)

**Scrape public [Naver Café](https://cafe.naver.com) content in one run — article lists, full post bodies, and comment threads.** Give the Actor a café (URL, café name, or clubId), an optional board or search keyword, and it returns the café's **metadata** (name, member count, manager, board list) plus its **articles** — each with title, board, author, member level, date, view/comment/like counts, full body text, and (optionally) the entire comment thread. Point it at a **direct article link** instead and it reads just that post. Built for **community monitoring, brand & keyword tracking, and market research** in the Korean market.

Because it runs on the Apify platform, you get scheduled runs, a REST API, webhooks and integrations (Google Sheets, Make, Zapier, Slack…), automatic proxy rotation through Korean IPs, and monitoring — no servers to manage.

### Why use Naver Café Scraper?

- **Community monitoring** — track a café or a single board (게시판) for new posts, with author, timestamp and engagement on every article.
- **Brand & keyword tracking** — use the in-café **search keyword** to pull every article mentioning your brand or product.
- **Market & competitor research** — Naver Cafés are where Korean hobby, product and fan communities actually talk; export the discussion as structured data.
- **Sentiment & comment analysis** — pull full comment threads (with reply structure and member levels) for any article.
- **Bulk collection** — feed many cafés or article links and get one tidy dataset.

### How to use Naver Café Scraper

1. Enter one or more **cafés or article links** — a café name (`steamindiegame`), a numeric clubId (`27842958`), a café URL (`https://cafe.naver.com/steamindiegame`), or a direct article link (`https://cafe.naver.com/steamindiegame/21892615`). A café link scrapes its article list; an article link reads just that post.
2. (Optional) Set a **board (menuId)** to restrict listing to one board, or a **search keyword** to pull matching articles instead of the recent feed.
3. (Optional) Set **Max articles per café** to cap collection — defaults to `5` for a quick, cheap first run; set `0` for no cap.
4. (Optional) Turn on **Include comments** to pull each article's comment thread.
5. Click **Start**. When the run finishes, open the **Output** tab and download the data as JSON, CSV, Excel, or HTML — or pull it from the API.

### Input

Configure the run in the **Input** tab (or via JSON / API). Key fields:

| Field                    | Description                                                                                       | Default                      |
| ------------------------ | ------------------------------------------------------------------------------------------------- | ---------------------------- |
| `cafes`                  | Café names, clubIds, café URLs, or article links — one per line. **Required.**                    | —                            |
| `menuId`                 | Restrict listing to one board by its Naver `menuId`. `0` = recent across the whole café.          | `0`                          |
| `keyword`                | In-café search keyword. When set, articles come from search results, not the recent feed.         | — (empty)                    |
| `maxArticles`            | Cap articles collected per café (newest first). `0` = no cap.                                      | `5`                         |
| `includeArticleContent`  | Fetch each article's full body (plain text and HTML).                                             | `true`                       |
| `includeComments`        | Fetch each article's comment thread (nested under the article).                                   | `false`                      |
| `maxCommentsPerArticle`  | Cap comments per article. `0` = all.                                                               | `0`                          |
| `includeMenus`           | Attach the café's board/menu tree (find `menuId`s here).                                           | `true`                       |
| `outputMode`             | `articleItems` = one item per article (+ a café item); `cafeItem` = one item per café, nested.    | `articleItems`               |
| `language`               | Language preference sent to Naver. Korean is strongly recommended.                                 | `ko`                         |
| `maxConcurrency`         | Cafés processed in parallel.                                                                       | `3`                          |
| `proxyConfiguration`     | Proxy for every request. Korean residential IPs recommended.                                       | Apify Proxy, RESIDENTIAL, KR |

Example input:

```json
{
    "cafes": ["https://cafe.naver.com/steamindiegame"],
    "keyword": "신작",
    "maxArticles": 100,
    "includeArticleContent": true,
    "includeComments": false,
    "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "KR" }
}
````

### Output

Results are written to the dataset in one of two shapes, chosen by `outputMode`:

- **`articleItems` (default)** — one dataset item per **article** (`"type": "article"`, each tagged with its café's `clubId` and `cafeName`), plus one **café** item per café (`"type": "cafe"`). Best for spreadsheets and per-article analysis.
- **`cafeItem`** — one item per **café** (`"type": "cafe"`) with all articles nested under an `articles` array. Best when you want a café and its whole harvest as a single object.

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

Example **café** item:

```json
{
    "type": "cafe",
    "clubId": "27842958",
    "cafeUrl": "steamindiegame",
    "cafeName": "왁물원 :: 종합 거시기 스트리머 우왁굳 팬카페",
    "url": "https://cafe.naver.com/steamindiegame",
    "memberCount": 567761,
    "managerNickname": "parable",
    "openType": "O",
    "menuCount": 766,
    "menus": [{ "menuId": 1, "menuName": "💩 자유 게시판", "menuType": "B", "boardType": "L" }]
}
```

Example **article** item (`content` present only when `includeArticleContent` is on; `comments` only when `includeComments` is on):

```json
{
    "type": "article",
    "clubId": "27842958",
    "cafeName": "왁물원",
    "articleId": "21892645",
    "url": "https://cafe.naver.com/steamindiegame/21892645",
    "menuId": 1952,
    "menuName": "자동차 게시판",
    "title": "\"갤로퍼의 후계자\" 현대 신형 '볼더' 양산되나",
    "writerNickname": "징 버 거",
    "memberLevel": 140,
    "writeDate": "2026-07-21T12:34:19.723Z",
    "readCount": 1,
    "commentCount": 0,
    "likeCount": 0,
    "tags": [],
    "content": "🚘 현대차 정통 오프로더 '볼더(Boulder)' 출원 소식 …",
    "contentLength": 503,
    "comments": []
}
```

#### Data fields

**Café**

| Field                            | Description                               |
| -------------------------------- | ----------------------------------------- |
| `clubId`                         | Numeric Naver café id.                    |
| `cafeUrl` / `url`                | Café vanity name and full URL.            |
| `cafeName`                       | Café title.                               |
| `memberCount`                    | Number of members.                        |
| `managerId` / `managerNickname`  | Café manager (운영자).                    |
| `openType`                       | `"O"` = open café.                        |
| `menus`                          | Board tree with `menuId` + name.          |

**Each article**

| Field                          | Description                                    |
| ------------------------------ | ---------------------------------------------- |
| `articleId`                    | Naver's article id.                            |
| `url`                          | Link to the article.                           |
| `menuId` / `menuName`          | The board it was posted in.                    |
| `title`                        | Article title.                                 |
| `writerNickname` / `memberLevel` | Author nickname and café member level.       |
| `writeDate`                    | Publish time (ISO 8601).                       |
| `readCount`                    | View count.                                    |
| `commentCount` / `likeCount`   | Comment and like (좋아요) counts.              |
| `tags`                         | Article tags.                                  |
| `content` / `contentLength`    | Full body text + length (opt-in).              |
| `contentHtml`                  | Original post HTML, as published (opt-in).     |
| `comments`                     | Comment thread (opt-in) — see below.           |

**Each comment** (when `includeComments` is on)

| Field                            | Description                                |
| -------------------------------- | ------------------------------------------ |
| `commentId` / `parentId`         | Comment id and parent (for replies).       |
| `isReply`                        | Whether it's a reply to another comment.   |
| `writerNickname` / `memberLevel` | Commenter nickname and level.              |
| `content` / `stickerUrl`         | Comment text and/or sticker image.         |
| `date`                           | Comment time (ISO 8601).                   |

### How much does it cost to scrape Naver Café?

This Actor uses **pay-per-event** pricing, so you pay for the results you get — not for time or servers. You're charged per **article** collected, with a small additional charge when you also pull an article's **full body** or its **comment thread**. Cost scales with what you collect: keep spend predictable with **Max articles per café**, or collect just list metadata by turning full content off. See the **Pricing** tab for current rates; the Apify free tier is enough to try it out.

### Tips & advanced options

- **Target one board:** find its `menuId` in a café record's `menus` list, then set the **Board (menuId)** input.
- **Keyword monitoring:** set a **search keyword** and schedule the Actor to re-run — you get a rolling feed of new mentions.
- **Cap busy cafés:** large cafés post constantly; set **Max articles per café** to keep runs fast and predictable.
- **Metadata-only, fast & cheap:** turn **Include full article content** off to collect just list metadata (title, author, date, counts).
- **Use Korean residential proxies:** Naver serves the most complete content to Korean IPs. The default (Apify Proxy, RESIDENTIAL, country KR) is strongly recommended for reliable results.

### FAQ, disclaimers & support

**Is scraping Naver Café legal?** This Actor collects only **publicly available** café content — what anyone can view in a browser without logging in. You are responsible for how you use the data, including compliance with Naver's Terms of Service and applicable laws (such as GDPR / PIPA) when handling any personal data. Do not use it to collect private or sensitive information.

**Why are some articles missing or bodyless?** Naver Cafés have per-café and per-board permissions. **Member-only** boards and closed cafés are not publicly readable, so gated articles are skipped (or kept with public list metadata but no body) and the rest of the run continues. This Actor does not log in and does not attempt to bypass access controls.

**Does it fetch images / attachments?** Article bodies are returned as text (`content`) and original HTML (`contentHtml`, which contains image URLs). Comment stickers are returned as image URLs. Binary files are not downloaded.

**Found a bug or need a custom solution?** Open a ticket on the **Issues** tab — feedback and feature requests are welcome.

# Actor input Schema

## `cafes` (type: `array`):

Naver cafés or article links — one per line. Accepts a café name (`steamindiegame`), a numeric clubId (`27842958`), a café URL (`https://cafe.naver.com/steamindiegame`), or a direct article link (`https://cafe.naver.com/steamindiegame/12345`). A café link scrapes its article list; an article link reads just that article.

## `menuId` (type: `integer`):

Restrict listing to a single board by its Naver menuId. Leave at 0 to list recent articles across the whole café. menuId values appear in each café record's `menus` list.

## `keyword` (type: `string`):

Optional in-café search keyword. When set, articles are pulled from the café's search results instead of the recent-article feed.

## `maxArticles` (type: `integer`):

Cap the number of articles scraped per café (newest first). Set to 0 for no cap. You are billed per article, so use this to control cost on busy cafés.

## `includeArticleContent` (type: `boolean`):

Fetch each article's full body (plain text + original HTML), not just the list metadata. Makes one extra request per article, so runs are slower — combine with 'Max articles per café' on busy cafés.

## `includeComments` (type: `boolean`):

Fetch each article's comment thread (one or more extra requests per article). Comments are nested under the article as a `comments` array.

## `maxCommentsPerArticle` (type: `integer`):

Cap comments collected per article when 'Include comments' is on. 0 = all comments.

## `includeMenus` (type: `boolean`):

Attach the café's board/menu tree (menuId + name) to the café record — handy for finding the menuId of a board you want to target.

## `outputMode` (type: `string`):

How results are stored. 'One item per article' emits a separate dataset item for every article (plus one café item per café) — best for spreadsheets. 'One item per café' emits a single record per café with all articles nested under an `articles` array.

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

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

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

Maximum cafés processed in parallel. Naver rate-limits aggressively and the Actor self-throttles, so keep this modest.

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

Proxy used for every request. Naver rate-limits datacenter and non-Korean IPs, so Korean residential proxies are strongly recommended. Defaults to Apify Proxy (RESIDENTIAL, country KR).

## Actor input object example

```json
{
  "cafes": [
    "steamindiegame",
    "https://cafe.naver.com/steamindiegame/21892615"
  ],
  "menuId": 0,
  "keyword": "신작",
  "maxArticles": 5,
  "includeArticleContent": true,
  "includeComments": false,
  "maxCommentsPerArticle": 0,
  "includeMenus": true,
  "outputMode": "articleItems",
  "language": "ko",
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "KR"
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "cafes": [
        "https://cafe.naver.com/steamindiegame"
    ],
    "maxArticles": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/naver-cafe-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 = {
    "cafes": ["https://cafe.naver.com/steamindiegame"],
    "maxArticles": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("hgservices/naver-cafe-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 '{
  "cafes": [
    "https://cafe.naver.com/steamindiegame"
  ],
  "maxArticles": 5
}' |
apify call hgservices/naver-cafe-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver Café Scraper (네이버 카페)",
        "description": "Scrape public Naver Café posts, comments and engagement stats — authors, dates, views and likes — from Korea's biggest community platform. Filter by café, board, or keyword.",
        "version": "0.1",
        "x-build-id": "OY3aqzvP0ea3WHGGg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hgservices~naver-cafe-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hgservices-naver-cafe-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-cafe-scraper/runs": {
            "post": {
                "operationId": "runs-sync-hgservices-naver-cafe-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-cafe-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-hgservices-naver-cafe-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": [
                    "cafes"
                ],
                "properties": {
                    "cafes": {
                        "title": "☕ Cafés or article links",
                        "type": "array",
                        "description": "Naver cafés or article links — one per line. Accepts a café name (`steamindiegame`), a numeric clubId (`27842958`), a café URL (`https://cafe.naver.com/steamindiegame`), or a direct article link (`https://cafe.naver.com/steamindiegame/12345`). A café link scrapes its article list; an article link reads just that article.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "menuId": {
                        "title": "Board (menuId)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Restrict listing to a single board by its Naver menuId. Leave at 0 to list recent articles across the whole café. menuId values appear in each café record's `menus` list.",
                        "default": 0
                    },
                    "keyword": {
                        "title": "🔍 Search keyword",
                        "type": "string",
                        "description": "Optional in-café search keyword. When set, articles are pulled from the café's search results instead of the recent-article feed."
                    },
                    "maxArticles": {
                        "title": "📄 Max articles per café",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the number of articles scraped per café (newest first). Set to 0 for no cap. You are billed per article, so use this to control cost on busy cafés.",
                        "default": 5
                    },
                    "includeArticleContent": {
                        "title": "Include full article content",
                        "type": "boolean",
                        "description": "Fetch each article's full body (plain text + original HTML), not just the list metadata. Makes one extra request per article, so runs are slower — combine with 'Max articles per café' on busy cafés.",
                        "default": true
                    },
                    "includeComments": {
                        "title": "Include comments",
                        "type": "boolean",
                        "description": "Fetch each article's comment thread (one or more extra requests per article). Comments are nested under the article as a `comments` array.",
                        "default": false
                    },
                    "maxCommentsPerArticle": {
                        "title": "Max comments per article",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap comments collected per article when 'Include comments' is on. 0 = all comments.",
                        "default": 0
                    },
                    "includeMenus": {
                        "title": "Include board list",
                        "type": "boolean",
                        "description": "Attach the café's board/menu tree (menuId + name) to the café record — handy for finding the menuId of a board you want to target.",
                        "default": true
                    },
                    "outputMode": {
                        "title": "Output shape",
                        "enum": [
                            "articleItems",
                            "cafeItem"
                        ],
                        "type": "string",
                        "description": "How results are stored. 'One item per article' emits a separate dataset item for every article (plus one café item per café) — best for spreadsheets. 'One item per café' emits a single record per café with all articles nested under an `articles` array.",
                        "default": "articleItems"
                    },
                    "language": {
                        "title": "🌍 Language",
                        "enum": [
                            "ko",
                            "en"
                        ],
                        "type": "string",
                        "description": "Accept-Language hint sent to Naver. Korean is strongly recommended — Naver serves Korean content regardless, and non-Korean hints can trigger stricter bot checks.",
                        "default": "ko"
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum cafés processed in parallel. Naver rate-limits aggressively and the Actor self-throttles, so keep this modest.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used for every request. Naver rate-limits datacenter and non-Korean IPs, so Korean residential proxies are strongly recommended. Defaults to Apify Proxy (RESIDENTIAL, country KR).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "KR"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
