# Naver Map Scraper (`solidcode/naver-map-scraper`) Actor

\[💰 $1.3 / 1K] Extract places from Naver Maps (map.naver.com) search results — business name, category, address, phone, website, rating, review count, opening hours, amenities, coordinates, plus inline menu and a sample of reviews. Search by keyword or paste Naver Maps URLs.

- **URL**: https://apify.com/solidcode/naver-map-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Naver Map Scraper

Pull places from Naver Maps — South Korea's dominant local-business map — at scale: name, category, both Korean address forms, phone, rating, opening hours, coordinates, inline menu prices, Korean TV-show appearances, and visitor review samples for every restaurant, café, hotel, hospital, clinic, salon, shop, or attraction your keyword surfaces. Built for Korea market researchers, lead-generation teams targeting Korean businesses, and location-data analysts who need clean, structured Naver place data without piecing it together one listing at a time.

### Why This Scraper?

- **Every Naver place category, not just food** — restaurants, cafés, hotels, hospitals, clinics, beauty salons, convenience stores, retail shops, attractions, and services all come back from a single keyword. Food-only scrapers return zero rows for a clinic like `유앤아이피부과`; this one returns the clinic.
- **Both Korean address formats on every row** — the modern road-name address (도로명) *and* the legacy lot-number address (지번), so the data matches whichever standard your CRM, mapping tool, or government dataset uses.
- **Inline visitor review samples** — the representative review text Naver shows on each place card, delivered right inside the row alongside the visitor rating and total review count.
- **Korean TV-appearance tags** — the program a place featured on (흑백요리사, 수요미식회, 2TV생생정보, and more) and the TV-featured dishes, captured inline. Spot the "맛집 on TV" venues your competitors miss.
- **Inline menu and price list for food places** — item name, price, and image for restaurants and cafés, captured straight from the place card with no extra step.
- **Precise GPS coordinates on every place** — latitude and longitude ready to drop onto a map, into a geospatial join, or into a radius calculation.
- **Both direct and virtual phone numbers** — falls back to Naver's `0507` virtual line when a place hides its direct number, so contactable leads aren't lost.
- **Opening hours, business status, and amenities** — current open/closed status, the hours description Naver shows, and characteristic keywords including wheelchair access (휠체어 입장 가능).
- **A per-search result cap** — the limit applies to each keyword or URL independently, so a multi-keyword run collects up to your cap for every term, not just the first. Set it to 0 to sweep an entire keyword's results.
- **Mirror a search you already set up** — paste any Naver Maps search URL and the scraper reproduces that exact result set, keyword and map area included.

### Use Cases

**Market Research**
- Map café, restaurant, or hospital density across Seoul districts like Gangnam or Hongdae
- Compare place counts and ratings between neighborhoods before entering a market
- Track which categories dominate a commercial area
- Benchmark competitor ratings and review volume side by side

**Lead Generation**
- Build outreach lists of Korean businesses with phone and booking links
- Target salons, clinics, or shops by keyword and district for B2B sales
- Capture virtual `0507` numbers for places that hide their direct line
- Pull contactable place lists for an entire keyword in one run

**Location Intelligence**
- Geocode places with ready-to-use latitude and longitude
- Join Naver places to your own geospatial datasets using either Korean address form
- Analyze opening hours and business status across a category

**Travel & Hospitality**
- Compile hotels, attractions, and restaurants for a destination guide
- Surface top-rated dining with inline menu prices for itinerary planning
- Collect review samples to gauge visitor sentiment per venue

**Retail Expansion**
- Scout existing stores and services in a target district before site selection
- Map convenience stores, shops, and amenities around a candidate address
- Track new place categories appearing in a growth area

### Getting Started

#### Simple keyword search

Just one Korean keyword — the fastest way to start:

```json
{
    "searchTerms": ["강남 맛집"]
}
````

#### Multiple searches with a result cap

Combine several keywords — the cap applies to each one, so this run collects up to 300 places per keyword:

```json
{
    "searchTerms": ["서울 카페", "홍대 미용실", "부산 호텔"],
    "maxResults": 300
}
```

#### Paste a Naver Maps URL and slim the output

Mirror a search you already opened on the site, and skip the heavier inline collections for a lighter run:

```json
{
    "startUrls": ["https://map.naver.com/p/search/강남%20맛집"],
    "maxResults": 100,
    "includeReviews": false,
    "includeMenu": false
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | string\[] | `["강남 맛집"]` | Keywords to search on Naver Maps, in Korean or romanized text — e.g. `강남 맛집` (Gangnam restaurants), `서울 카페` (Seoul café), or a specific business name. Add as many as you like. |
| `startUrls` | string\[] | `[]` | Paste Naver Maps search URLs directly (e.g. `https://map.naver.com/p/search/강남%20맛집`). When provided, these are used instead of the search terms above. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `50` | Caps the number of places collected for **each** search term or URL (e.g. two terms with a cap of 50 returns up to ~100 places). Set to 0 to collect as many as available. Results come in full pages, so the actual count may slightly exceed this. |

#### Place Details

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeReviews` | boolean | `true` | Include the sample of visitor reviews Naver shows for each place. Turn off for a lighter, faster run when you only need the place details. |
| `includeMenu` | boolean | `true` | Include the menu and price list shown for restaurants and cafés (item name, price, and image). Has no effect for places without a menu. |

### Output

Each place becomes one row. Here is a representative result with reviews and menu enabled:

```json
{
    "placeId": "1234567890",
    "name": "스시 오마카세 강남",
    "category": "일식당",
    "businessStatus": "영업 중",
    "address": "서울특별시 강남구 테헤란로 123",
    "addressJibun": "서울특별시 강남구 역삼동 678-9",
    "roadAddress": "서울특별시 강남구 테헤란로 123",
    "fullAddress": "서울특별시 강남구 테헤란로 123 2층",
    "phone": "02-555-1234",
    "website": "https://booking.naver.com/booking/12/bizes/123456",
    "rating": 4.62,
    "reviewCount": 3322,
    "visitorReviewCount": 1840,
    "blogReviewCount": 1482,
    "businessHours": { "status": "영업 중", "description": "11:30 - 22:00" },
    "amenities": ["주차", "예약", "휠체어 입장 가능"],
    "description": "신선한 제철 재료로 만드는 오마카세 전문점",
    "latitude": 37.500123,
    "longitude": 127.036456,
    "naverUrl": "https://map.naver.com/p/entry/place/1234567890",
    "thumbnailUrl": "https://ldb-phinf.pstatic.net/example.jpg",
    "imageUrls": ["https://ldb-phinf.pstatic.net/example1.jpg"],
    "tvAppearances": [
        { "program": "흑백요리사2", "channel": null, "date": null, "menu": null, "episode": null }
    ],
    "menuItems": [
        { "name": "런치 오마카세", "price": "55,000원", "imageUrl": "https://ldb-phinf.pstatic.net/menu1.jpg" }
    ],
    "reviews": [
        { "author": null, "rating": null, "text": "재료가 신선하고 분위기가 좋아요", "date": null }
    ],
    "searchTerm": "강남 맛집"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `placeId` | string | Naver place identifier |
| `name` | string | Business / place name |
| `category` | string | Primary category (e.g. 음식점, 카페, 병원) |
| `businessStatus` | string | Open / closed status, when shown |
| `description` | string | Place intro text or short review summary |
| `searchTerm` | string | The keyword or URL that produced this row |
| `naverUrl` | string | Canonical Naver place page URL |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Primary (road-name 도로명) address |
| `roadAddress` | string | Road-name address (도로명) |
| `addressJibun` | string | Legacy lot-number (지번) address |
| `fullAddress` | string | Full address including floor / unit, when present |
| `latitude` | number | Latitude |
| `longitude` | number | Longitude |

#### Contact

| Field | Type | Description |
|-------|------|-------------|
| `phone` | string | Direct phone, falling back to Naver's `0507` virtual number |
| `website` | string | Homepage or booking URL, when listed |

#### Ratings & Reviews

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | Overall visitor rating |
| `reviewCount` | integer | Total reviews (visitor + blog) |
| `visitorReviewCount` | integer | Visitor review count |
| `blogReviewCount` | integer | Blog / café review count |
| `reviews` | object\[] | Inline review sample `{ author, rating, text, date }`. Naver's search cards surface the review **text**; `author`, `rating`, and `date` are returned as `null` when the card doesn't carry them. Present when `includeReviews` is on |

#### Hours, Amenities & Media

| Field | Type | Description |
|-------|------|-------------|
| `businessHours` | object | `{ status, description }` — current status and hours text |
| `amenities` | string\[] | Characteristic keywords (parking, reservation, wheelchair access, etc.) |
| `thumbnailUrl` | string | Lead image URL |
| `imageUrls` | string\[] | Small set of inline image URLs |
| `tvAppearances` | object\[] | Korean TV / broadcast tags `{ program, channel, date, menu, episode }` — the show a place featured on and any TV-highlighted dish. Empty for places with no broadcast history |
| `menuItems` | object\[] | Inline menu sample `{ name, price, imageUrl }`. Present when `includeMenu` is on |

### Tips for Best Results

- **Search in Korean for the richest results** — Naver is a Korea-focused service, so Korean keywords return more places and fuller detail than romanized terms.
- **Use the `지역 + 업종` pattern** — pair a district with a business type, like `강남 맛집` (Gangnam restaurants) or `홍대 카페` (Hongdae cafés), to get tightly relevant places.
- **Paste a Naver Maps URL to reproduce an exact search** — set up a search on the site, copy the URL into `startUrls`, and the run mirrors that exact result set, map area included.
- **Toggle off reviews and menu for lean, fast runs** — when you only need the place table (name, address, phone, coordinates), turn off `includeReviews` and `includeMenu` to slim each row.
- **The result cap is per search** — `maxResults` applies to each keyword or URL separately, so a run with three keywords and a cap of 50 returns up to 50 places for every keyword (about 150 total). Lower the cap if you only need a quick sample per term.
- **Start with a small `maxResults`** — try 50 first to confirm the data fits your needs, then raise the cap or set it to 0 to sweep everything.
- **Hunt for TV-featured venues** — `tvAppearances` flags places that have aired on Korean food and travel shows. Filter your output to non-empty `tvAppearances` to surface the "맛집 on TV" spots, a strong signal for popularity and footfall.
- **Expect a few sparse fields** — `rating`, `menuItems`, and `tvAppearances` only appear when Naver surfaces them on a place card, so some rows return them empty. This reflects the live listing, not a gap in collection.
- **Both address forms travel together** — if you join Naver data to a government or postal dataset, pick `roadAddress` for modern records or `addressJibun` for legacy lot-number records.

### Pricing

**From $1.30 per 1,000 results** — among the lowest prices on Apify for Naver Maps place data, and below the going market rate. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.16 | $0.15 | $0.14 | $0.13 |
| 1,000 | $1.55 | $1.45 | $1.40 | $1.30 |
| 10,000 | $15.50 | $14.50 | $14.00 | $13.00 |
| 100,000 | $155.00 | $145.00 | $140.00 | $130.00 |

A "result" is any place row in the output dataset. Platform fees depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, business intelligence, and lead generation. Users are responsible for complying with applicable laws and Naver's Terms of Service. Do not use extracted data for spam, harassment, or any illegal purpose, and handle any personal data (such as review content) in line with applicable privacy regulations.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search on Naver Maps, in Korean or romanized text — for example '강남 맛집' (Gangnam restaurants), '서울 카페' (Seoul cafe), or a specific business name. Add as many as you like.

## `startUrls` (type: `array`):

Paste Naver Maps search URLs directly (e.g. https://map.naver.com/p/search/강남%20맛집). When provided, these are used instead of the search terms above — the fastest way to mirror a search you already set up on the site.

## `maxResults` (type: `integer`):

Caps the number of places collected for EACH search term or URL. With two search terms and a cap of 50, you get up to 50 places per term (about 100 total). Set to 0 to collect all available. Results come in full pages, so the actual count may slightly exceed this number.

## `includeReviews` (type: `boolean`):

Include the sample of visitor reviews that Naver shows for each place — the review text Naver surfaces on the place card. Turn off for a lighter, faster run when you only need the place details.

## `includeMenu` (type: `boolean`):

Include the menu and price list shown for restaurants and cafes (item name, price, and image). Has no effect for places without a menu.

## Actor input object example

```json
{
  "searchTerms": [
    "강남 맛집"
  ],
  "startUrls": [],
  "maxResults": 50,
  "includeReviews": true,
  "includeMenu": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped places with key fields.

## `contact` (type: `string`):

Table of contact information and location for scraped places.

# 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 = {
    "searchTerms": [
        "강남 맛집"
    ],
    "startUrls": [],
    "maxResults": 50,
    "includeReviews": true,
    "includeMenu": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/naver-map-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 = {
    "searchTerms": ["강남 맛집"],
    "startUrls": [],
    "maxResults": 50,
    "includeReviews": True,
    "includeMenu": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/naver-map-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 '{
  "searchTerms": [
    "강남 맛집"
  ],
  "startUrls": [],
  "maxResults": 50,
  "includeReviews": true,
  "includeMenu": true
}' |
apify call solidcode/naver-map-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver Map Scraper",
        "description": "[💰 $1.3 / 1K] Extract places from Naver Maps (map.naver.com) search results — business name, category, address, phone, website, rating, review count, opening hours, amenities, coordinates, plus inline menu and a sample of reviews. Search by keyword or paste Naver Maps URLs.",
        "version": "1.0",
        "x-build-id": "NCs4dbRwZQQcdE3sk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~naver-map-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-naver-map-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/solidcode~naver-map-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-naver-map-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/solidcode~naver-map-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-naver-map-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": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Keywords to search on Naver Maps, in Korean or romanized text — for example '강남 맛집' (Gangnam restaurants), '서울 카페' (Seoul cafe), or a specific business name. Add as many as you like.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Naver Maps URLs",
                        "type": "array",
                        "description": "Paste Naver Maps search URLs directly (e.g. https://map.naver.com/p/search/강남%20맛집). When provided, these are used instead of the search terms above — the fastest way to mirror a search you already set up on the site.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Results per Search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Caps the number of places collected for EACH search term or URL. With two search terms and a cap of 50, you get up to 50 places per term (about 100 total). Set to 0 to collect all available. Results come in full pages, so the actual count may slightly exceed this number.",
                        "default": 50
                    },
                    "includeReviews": {
                        "title": "Include Reviews",
                        "type": "boolean",
                        "description": "Include the sample of visitor reviews that Naver shows for each place — the review text Naver surfaces on the place card. Turn off for a lighter, faster run when you only need the place details.",
                        "default": true
                    },
                    "includeMenu": {
                        "title": "Include Menu & Prices",
                        "type": "boolean",
                        "description": "Include the menu and price list shown for restaurants and cafes (item name, price, and image). Has no effect for places without a menu.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```