# Naver Blog Scraper — Search + Post Content + Cafe \[$1.5💰] (`memo23/naver-blog-scraper`) Actor

Naver Blog scraper — paste a keyword for blog search, a blog.naver.com post URL for full Korean post content, or a cafe ID for public cafe articles. Flat JSON rows, optional post-body enrichment, date filters. Pure HTTP, no login. $1.50/1k rows

- **URL**: https://apify.com/memo23/naver-blog-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** News, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 naver rows

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/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 Blog Scraper — Blog Search + Post Content + Cafe Articles

<p align="center">
  <img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/naver-blog-logo.png" alt="Naver Blog Scraper logo" width="160" />
</p>

Turn Naver Blog and public Naver Cafes into structured data.
Paste a keyword to search Naver's blog index, a `blog.naver.com` post URL to pull the full Korean post body, or a cafe ID to list a public cafe's articles — every query line is auto-classified, and every row is flat, UTF-8-clean JSON.

### Why Use This Scraper?

- ✅ Three sources in one actor — blog keyword search, full post content, public cafe articles
- ✅ Paste keywords, post URLs, or cafe IDs together — each line auto-routed
- ✅ Optional post-body enrichment — attach full text, images, and tags to every search hit
- ✅ Korean-safe UTF-8 output end to end — no mojibake in titles, bodies, or nicknames
- ✅ Date-range filters and relevance / recency sorting for search
- ✅ Pure HTTP over Naver's open endpoints — no login, no browser, and proxies are optional

### Overview

The Naver Blog Scraper is built for marketing and influencer agencies, brand-monitoring teams, SEO specialists, and researchers who need structured data out of Korea's dominant blogging and community platform.

The output is a stream of flat rows carrying a `type` discriminator: a keyword yields **searchResult rows**, a post URL yields one **post row** with the full body, and a cafe ID yields **cafeArticle rows**. Every row echoes the originating `query`, so mixed runs stay trivial to split downstream. Turn on `includePostContent` and each search result is upgraded in place with the post's body text, images, and tags.

### Supported Inputs

#### Query types (auto-detected per line)

| Query type | Pattern | Example | Rows produced |
|---|---|---|---|
| Blog keyword search | free text (any language) | `맛집` or `seoul cafe` | one searchResult row per matching post |
| Full post content | `blog.naver.com` / `m.blog.naver.com` URL | `https://blog.naver.com/someblog/223340163450` | one post row with the full body |
| Public cafe articles | `cafeId:{clubId}` or cafe URL | `cafeId:10322296` or `https://cafe.naver.com/joonggonara` | one cafeArticle row per article |

#### Copy-pasteable input

```json
{
  "queries": [
    "맛집",
    "https://blog.naver.com/someblog/223340163450",
    "cafeId:10322296"
  ],
  "maxItems": 200
}
````

#### Unsupported inputs

- ❌ Members-only / private cafe boards (only public cafe articles are returned)
- ❌ Naver Shopping, Maps, or Place data — those are separate, heavily protected surfaces
- ❌ Content behind a Naver login, and posts the author has set to private

### Use Cases

| Audience | Use case |
|---|---|
| **Influencer / blog-marketing agencies** | Find relevant bloggers, verify sponsored posts went live, measure reach, track competitor campaigns |
| **Brand & reputation teams** | Monitor what Korean bloggers say about a brand; catch negative reviews early |
| **SEO / content teams** | Reverse-engineer what ranks in Naver search; keyword and content-gap research |
| **Market researchers** | Aggregate blog mentions of a product or topic for trend and sentiment analysis |
| **Community analysts** | Track discussion volume and topics across public Naver Cafes |

### How It Works

![How the Naver Blog Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-naver-blog.png)

1. **Input** — add any mix of keywords, post URLs, and cafe IDs, one per line
2. **Classify** — each line is auto-routed: free text → blog search JSON API, post URL → mobile post page, cafe ID → cafe article API
3. **Fetch** — the actor calls Naver's open endpoints over plain HTTP with polite concurrency, retries, and back-off
4. **Enrich (optional)** — with `includePostContent`, each search result also fetches its mobile post page for body text, images, and tags
5. **Output** — flat, typed, UTF-8 JSON rows land in the dataset, exportable as JSON, CSV, Excel, or XML

### Input Configuration

#### Input fields

| Field | Type | Required | Notes |
|---|---|---|---|
| `queries` | `array<string>` | yes | One query per line; each auto-classified (see Supported Inputs) |
| `includePostContent` | `boolean` | optional | Enrich each search result with full body text, images, tags. Roughly doubles requests. Default `false` |
| `orderBy` | `string` enum | optional | Search sort: `sim` (relevance) or `recentdate` (newest). Default `sim` |
| `from` | `string` (date) | optional | Search mode only: results published on/after `YYYY-MM-DD` |
| `to` | `string` (date) | optional | Search mode only: results published on/before `YYYY-MM-DD`; empty = up to now |
| `maxItems` | `integer` | optional | Global cap on rows across all queries. Default `100` |
| `maxConcurrency` | `integer` | optional | Parallel requests, default `3`, hard cap `10` — Naver scores IP reputation, keep it low |
| `proxy` | `object` | optional | Off by default. Enable Apify residential proxies if you hit blocks or CAPTCHA responses |

#### Common scenarios

**1. Blog search, newest first, enriched with full post bodies**

```json
{
  "queries": ["강남 카페"],
  "includePostContent": true,
  "orderBy": "recentdate",
  "maxItems": 50
}
```

**2. Date-sliced harvest (get past Naver's ~1,000-result cap)**

```json
{
  "queries": ["신제품 리뷰"],
  "orderBy": "recentdate",
  "from": "2026-01-01",
  "to": "2026-03-31",
  "maxItems": 1000
}
```

**3. Public cafe article list**

```json
{
  "queries": ["cafeId:10322296"],
  "maxItems": 300
}
```

### Output Overview

Every row is flat and carries `type`, `query`, and `scrapedAt`, plus:

- **searchResult rows** — post URL, title, snippet, blogId, logNo, author nickname, blog name, publish date, thumbnail URLs, and `totalCount` for the query. With `includePostContent`, also `bodyText`, `bodyImageUrls`, and `tags`.
- **post rows** — post URL, blogId, logNo, title, author, publish date, full `bodyText`, `bodyImageUrls`, and `tags`.
- **cafeArticle rows** — cafe ID and name, article ID and URL, subject, board (menu) name, writer nickname, read/comment/like counts, write date, and whether the article has images.

### Output Samples

#### Keyword query → searchResult row (trimmed)

```jsonc
{
  "type": "searchResult",
  "query": "카페",
  "postUrl": "https://blog.naver.com/hope95_08_30/224343354021",
  "title": "구로디지털단지 카페드루와ㅣ가성비카페 내돈내산 솔직후기",
  "snippet": "구로디지털단지 가성비카페 카페드루와 … 오늘 소개해 드릴 곳은 …",
  "blogId": "hope95_08_30",
  "logNo": "224343354021",
  "authorName": "찌니",
  "blogName": "찌니와 동이의 일상",
  "blogUrl": "https://blog.naver.com/hope95_08_30",
  "postDate": "2026-07-12T00:00:00.000Z",
  "thumbnailUrls": ["https://blogthumb.pstatic.net/…"],
  "totalCount": 1000,
  "scrapedAt": "2026-07-17T…"
  /* + bodyText, bodyImageUrls, tags when includePostContent is on */
}
```

#### Post URL query → post row (trimmed)

```jsonc
{
  "type": "post",
  "query": "https://blog.naver.com/yeewon1217/223340163450",
  "postUrl": "https://blog.naver.com/yeewon1217/223340163450",
  "mobilePostUrl": "https://m.blog.naver.com/yeewon1217/223340163450",
  "blogId": "yeewon1217",
  "logNo": "223340163450",
  "title": "2024년 1월 이야기",
  "authorName": "에온",
  "publishedAt": "2024-01-…",
  "bodyText": "…1,518 characters of Korean post body…",
  "bodyImageUrls": ["https://postfiles.pstatic.net/…", "… 71 images …"],
  "tags": []
}
```

#### Cafe query → cafeArticle row

```jsonc
{
  "type": "cafeArticle",
  "query": "cafeId:10322296",
  "cafeId": "10322296",
  "cafeName": "ㆍ피터팬의 좋은방 구하기ㆍ",
  "articleId": "19570814",
  "articleUrl": "https://cafe.naver.com/ca-fe/cafes/10322296/articles/19570814",
  "subject": "거주후기",
  "menuName": "거주 후기",
  "writerNickname": "오오육아라",
  "maskedMemberId": "chae****",
  "readCount": 0,
  "commentCount": 0,
  "likeCount": 0,
  "hasImage": false,
  "scrapedAt": "2026-07-17T…"
}
```

### Key Output Fields

#### Common

- `type`, `query`, `scrapedAt`

#### Blog search result

- `postUrl`, `title`, `snippet`, `blogId`, `logNo`, `gdid`
- `authorName`, `blogName`, `blogUrl`, `postDate`, `thumbnailUrls`, `totalCount`

#### Blog post

- `title`, `authorName`, `publishedAt`, `bodyText`
- `bodyImageUrls`, `tags`, `mobilePostUrl`

#### Cafe article

- `cafeId`, `cafeName`, `articleId`, `articleUrl`, `subject`, `menuName`
- `writerNickname`, `maskedMemberId`, `readCount`, `commentCount`, `likeCount`, `writeDate`, `hasImage`

### FAQ

#### Do I need a proxy?

Usually not — Naver's blog search API and mobile post pages are open and work without a proxy from most IPs. But Naver does score IP reputation, so if you run at high volume and start seeing blocks or CAPTCHA responses, enable Apify residential proxies in the `proxy` input.

#### How does the actor decide which mode to run?

By the shape of each query line: a `blog.naver.com`/`m.blog.naver.com` URL fetches full post content, `cafeId:` or a `cafe.naver.com` URL lists cafe articles, and anything else is a blog keyword search. Mix all three in one run.

#### Why do I only get about 1,000 results for a popular keyword?

Naver caps every blog search query at roughly 1,000 reachable results. To harvest more, sort by `recentdate` and split the run into `from`/`to` date ranges — each slice returns its own up-to-1,000 window.

#### What does `includePostContent` cost me?

It fetches each search result's mobile post page for the full body, which roughly doubles the number of requests per run. Keep `maxItems` modest when it's on, and expect longer runtimes.

#### Can I scrape private or members-only content?

No. The actor reads only public blog posts and public cafe articles. Members-only cafe boards, private posts, and anything behind a Naver login are out of scope.

#### Does it handle Korean text correctly?

Yes — the entire pipeline is UTF-8, so Korean titles, post bodies, tags, and cafe nicknames come through intact with no mojibake.

#### Does this scrape Naver Shopping, Maps, or Place reviews?

No. Those surfaces use different, heavily protected endpoints and are not covered by this actor.

### Support

- For issues or feature requests, please use the **Issues** tab on the actor's Apify Console page.
- Author's website: <https://muhamed-didovic.github.io/>
- Email: <muhamed.didovic@gmail.com>

### Additional Services

- Need Naver Place / Maps / Shopping coverage, comment threads, or scheduled monitoring? Those are bigger builds — drop a line and I'll scope them.
- Custom output shapes, private builds, or direct API access (no Apify fee, just a usage fee): <muhamed.didovic@gmail.com>

### Explore More Scrapers

If you found this useful, you might also like:

- [**Internet Archive Scraper**](https://apify.com/memo23/internet-archive-scraper) — Wayback snapshots, library search, and item metadata
- [**Trustpilot Scraper**](https://apify.com/memo23/trustpilot-scraper-ppe) — company reviews at scale
- [**VRBO Scraper**](https://apify.com/memo23/vrbo-scraper) — vacation rentals with calendar, rates, and full reviews

Full list at [apify.com/memo23](https://apify.com/memo23).

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by NAVER Corporation or any of its subsidiaries. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available data on blog.naver.com and public Naver Cafe boards — no authenticated endpoints, no members-only boards, and no content behind the Naver login. Users are responsible for ensuring their use complies with NAVER's Terms of Service, applicable data-protection law (South Korea's PIPA, GDPR, CCPA, etc.), and any contractual obligations of their own organization. Please keep concurrency low to respect Naver's infrastructure.

***

### SEO Keywords

naver blog scraper, scrape naver blog, naver blog API, blog.naver.com scraper, naver cafe scraper, naver blog search, korean blog scraper, naver blog crawler, naver post content extraction, naver blog data, korea influencer marketing data, naver blog monitoring, korean social media scraper, naver SEO research, blog review scraper, korean market research data, naver cafe articles, Apify naver, naver blog CSV export, korea brand monitoring

# Actor input Schema

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

One query per line. Examples: `맛집` (blog keyword search), `https://blog.naver.com/someblog/223340163450` (full post content), `cafeId:10050146` or `https://cafe.naver.com/joonggonara` (public cafe article list). Korean, English, and mixed-language keywords all work.

## `includePostContent` (type: `boolean`):

When enabled, each blog search result is enriched with the post's full body text, image URLs, and tags fetched from its mobile page. **This roughly doubles the number of requests per run** (one extra request per search result) — keep `maxItems` modest when it is on.

## `orderBy` (type: `string`):

Sort order for blog search results. Relevance is Naver's default ranking; Most recent sorts by publish date (best for date-range harvesting).

## `from` (type: `string`):

Only return blog search results published on or after this date (YYYY-MM-DD). Applies to search-mode queries only. Naver caps every search query at ~1,000 reachable results — slice a large harvest into date ranges to get past the cap.

## `to` (type: `string`):

Only return blog search results published on or before this date (YYYY-MM-DD). Applies to search-mode queries only. Leave empty for 'up to now'.

## `maxItems` (type: `integer`):

Hard cap on total dataset rows across all queries.

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

How many requests run in parallel. Naver scores IP reputation — keep this low (hard-capped at 10).

## `proxy` (type: `object`):

Optional. Naver's open endpoints work without a proxy from most IPs, but Naver does IP-reputation scoring — if you see blocks or CAPTCHA responses, enable Apify residential proxies here.

## Actor input object example

```json
{
  "queries": [
    "맛집"
  ],
  "includePostContent": false,
  "orderBy": "sim",
  "maxItems": 100,
  "maxConcurrency": 3,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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("memo23/naver-blog-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("memo23/naver-blog-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 memo23/naver-blog-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver Blog Scraper — Search + Post Content + Cafe [$1.5💰]",
        "description": "Naver Blog scraper — paste a keyword for blog search, a blog.naver.com post URL for full Korean post content, or a cafe ID for public cafe articles. Flat JSON rows, optional post-body enrichment, date filters. Pure HTTP, no login. $1.50/1k rows",
        "version": "0.1",
        "x-build-id": "T8kexC1VGqHgPtJsN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~naver-blog-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-naver-blog-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/memo23~naver-blog-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-naver-blog-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/memo23~naver-blog-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-naver-blog-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",
                "properties": {
                    "queries": {
                        "title": "Keywords, post URLs, or cafe identifiers",
                        "type": "array",
                        "description": "One query per line. Examples: `맛집` (blog keyword search), `https://blog.naver.com/someblog/223340163450` (full post content), `cafeId:10050146` or `https://cafe.naver.com/joonggonara` (public cafe article list). Korean, English, and mixed-language keywords all work.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includePostContent": {
                        "title": "Fetch full post content for search results",
                        "type": "boolean",
                        "description": "When enabled, each blog search result is enriched with the post's full body text, image URLs, and tags fetched from its mobile page. **This roughly doubles the number of requests per run** (one extra request per search result) — keep `maxItems` modest when it is on.",
                        "default": false
                    },
                    "orderBy": {
                        "title": "Search sort order",
                        "enum": [
                            "sim",
                            "recentdate"
                        ],
                        "type": "string",
                        "description": "Sort order for blog search results. Relevance is Naver's default ranking; Most recent sorts by publish date (best for date-range harvesting).",
                        "default": "sim"
                    },
                    "from": {
                        "title": "From date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only return blog search results published on or after this date (YYYY-MM-DD). Applies to search-mode queries only. Naver caps every search query at ~1,000 reachable results — slice a large harvest into date ranges to get past the cap."
                    },
                    "to": {
                        "title": "To date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only return blog search results published on or before this date (YYYY-MM-DD). Applies to search-mode queries only. Leave empty for 'up to now'."
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on total dataset rows across all queries.",
                        "default": 100
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many requests run in parallel. Naver scores IP reputation — keep this low (hard-capped at 10).",
                        "default": 3
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Naver's open endpoints work without a proxy from most IPs, but Naver does IP-reputation scoring — if you see blocks or CAPTCHA responses, enable Apify residential proxies here.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
