# Naver Maps Scraper (`hgservices/naver-maps-scraper`) Actor

Extract business/place data from thousands of Naver Maps locations and businesses (map.naver.com), including name, category, address, map coordinates, phone, opening hours, menus with prices and photos, amenities, payment info, visitor and blog reviews, review counts and rating score.

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

## Pricing

from $1.50 / 1,000 place scraped - primaries

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/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 Maps Scraper

Extract business and place data from [Naver Maps](https://map.naver.com) — Korea's dominant maps service — without an API key or a headless browser. Give it a search term (and optionally an area) and get back clean, structured records: names, categories, addresses, map coordinates, phone numbers, opening hours, menus with prices and photos, amenities, payment info, visitor and blog reviews, review counts and rating scores.

Naver Maps is where Korean consumers actually find restaurants, cafés, clinics and shops — data you can't get from Google Maps, which has limited coverage in South Korea. If you're doing lead generation, market research or local SEO for the Korean market, this is the source.

### 📍 What is Naver Maps Scraper?

Use it to:

- **Generate local business leads** — pull every café, restaurant or clinic in a district with phone numbers and addresses.
- **Do market & competitor research** — rating scores and review counts across a whole city, not just the first 300 hits.
- **Build and enrich place datasets** — categories, coordinates, business hours, conveniences and full menus for mapping or analysis.
- **Track reviews** — visitor reviews and external blog reviews per place, with ratings, dates and full text.

### Beats Naver's 300-result cap

Naver's place search returns **at most 300 results for any single query** — so a naïve scraper silently stops at 300 even when a district has thousands of matches. Give this Actor a **Location** and it splits the area into a grid of tiles, searches each one, and de-duplicates across them — recovering the full result set for an entire neighbourhood or city. It's the same "subdivide the map to beat the per-viewport cap" strategy the leading Google Maps scrapers use.

### What data does it extract?

Every place record includes:

| Field                                     | Example                                        |
| ----------------------------------------- | ---------------------------------------------- |
| `name`                                    | 영동그집                                       |
| `category`                                | 육류,고기요리                                  |
| `address` / `roadAddress`                 | 서울특별시 강남구 봉은사로1길 42-8             |
| `location`                                | `{ "lat": 37.507466, "lng": 127.024445 }`      |
| `phone`                                   | 02-539-1234 _(when published; often absent)_   |
| `visitorReviewScore`                      | 4.84                                           |
| `totalReviewCount` / `visitorReviewCount` | 2137 / 1180                                    |
| `imageCount`                              | 12                                             |
| `url`                                     | https://map.naver.com/p/entry/place/1005495070 |
| `placeId`                                 | 1005495070                                     |

Turn on **Scrape place detail pages** to also get business hours, conveniences, payment info, full menus (name / price / description / photos) and review content — see [Place details](#place-details) below.

### Input

Configure the run from the Apify UI, or via the API. Main options:

- **🔍 Search term(s)** _(required, unless you scrape by URL / ID below)_ — what you'd type into Naver's search bar, e.g. `삼겹살` (pork BBQ), `카페` (café). Korean terms match best; one per line.
- **📍 Location** — a free-text area such as `Gangnam, Seoul` or `강남구`. This is what unlocks scraping past the 300-result cap. Leave it empty for a plain keyword search (hard-capped at 300).
- **📐 Structured location** — instead of free-text Location, narrow the area using **South Korea's own administrative hierarchy**: **Province / Metropolitan city** (시·도), **City / County / District** (시·군·구), **Town / Neighborhood** (읍·면·동) and **Postal code** (우편번호). Fill any combination and they're resolved together to one area (always within South Korea, the only country Naver Maps covers). Useful when a free-text name is ambiguous.
- **🛰 Custom search area** — an exact bounding box `[minLng, minLat, maxLng, maxLat]` if you'd rather define the area yourself.
- **🔗 Scrape specific places by URL / ID** — skip searching entirely and scrape exactly the places you list. Paste Naver Maps place URLs (`map.naver.com/p/entry/place/…`, `pcmap`/`m.place.naver.com`, or `naver.me` short links — resolved automatically) and/or raw numeric place IDs. When provided, this **takes priority over the search term and area**, and every listed place is fetched with full details.
- **💯 Max places per search term** — how many unique places to collect per term. Set this high together with a Location to sweep an entire area.

> **Which area wins?** If you set more than one, the most specific one is used: **Custom search area → Structured location → Location**.

- **Scrape place detail pages** — fetch menus, business hours, conveniences and review content (one extra request per place).
- **Reviews per place** — with details on, how many visitor + blog reviews to include per place (0 = review totals only).
- **🌍 Language** — response language for details: Korean, English, Japanese or Chinese.

> Proxy is handled automatically — every run goes through Apify Residential proxy in **South Korea**, since Naver is geo-sensitive and rate-limits foreign/datacenter IPs. There's nothing to configure.

#### Example

```json
{
    "searchStrings": ["삼겹살"],
    "locationQuery": "Gangnam, Seoul",
    "maxPlacesPerSearch": 500
}
````

Or narrow the same area with structured fields instead of free text:

```json
{
    "searchStrings": ["삼겹살"],
    "province": "Seoul",
    "municipality": "Gangnam-gu",
    "maxPlacesPerSearch": 500
}
```

Or scrape specific places directly (no search term needed):

```json
{
    "placeUrls": ["https://map.naver.com/p/entry/place/1005495070"],
    "placeIds": ["1102875830"],
    "maxReviewsPerPlace": 10
}
```

### Output

Results are stored as a dataset — **one item per place** — which you can export to JSON, CSV, Excel or query via the API. A place record looks like:

```json
{
    "placeId": "1005495070",
    "name": "영동그집",
    "category": "육류,고기요리",
    "roadAddress": "서울특별시 강남구 봉은사로1길 42-8",
    "phone": null,
    "location": { "lat": 37.507466, "lng": 127.024445 },
    "imageCount": 12,
    "totalReviewCount": 2137,
    "visitorReviewCount": 1180,
    "visitorReviewScore": 4.84,
    "url": "https://map.naver.com/p/entry/place/1005495070",
    "searchString": "삼겹살",
    "scrapedAt": "2026-07-16T09:20:00.000Z"
}
```

Reviews, blog reviews and menus are nested arrays inside each place record. For a flat "one row per review / menu" export, switch the dataset **view** in the output tab — the Actor ships **Places**, **Reviews**, **Blog reviews** and **Menus** views that unwind those arrays for you at export time.

<a id="place-details"></a>

### Place details

With **Scrape place detail pages** enabled, each record additionally carries:

- `businessHours` — opening hours per day, including days off
- `conveniences` — e.g. reservations, Wi-Fi, parking
- `virtualPhone`, `paymentInfo`, `categoryCode`
- `menus` — item name, price, recommended flag, description and photo URLs
- `visitorReviewTotal`, `blogReviewTotal`
- With **Reviews per place** > 0: `reviews` (visitor reviews — rating, full text, visit dates, tags) and `blogReviews` (external blog posts — contents, URL, date)

### FAQ

**Do I need a Naver API key or account?**
No. The Actor reads publicly available data from Naver Maps directly — no key, login or credentials required.

**Why does it use a Korean proxy?**
Naver serves and rate-limits by geography. Requests from South Korean residential IPs are far more reliable and less likely to hit a captcha, so the Actor routes every run through Apify's Residential proxy in KR. This is handled internally — there's no proxy setting to configure.

**How do I get more than 300 results?**
Provide a **Location** (or Custom search area). Naver caps a single query at 300 results, so the Actor tiles the area into smaller regions, searches each, and merges the results — letting you cover a whole district or city. A plain keyword search with no location stays capped at 300.

**Which search terms work best?**
Korean-language terms match Naver's index best (e.g. `카페` rather than "cafe"). You can pass several terms, one per line.

**Is web scraping legal?**
This Actor collects publicly available information. As with any scraping, you're responsible for how you use the data — in particular, complying with Naver's terms and applicable laws (including data-protection rules such as GDPR when personal data is involved). If in doubt, seek legal advice.

**Can I run it on a schedule or from my own app?**
Yes. Like any Apify Actor it can be scheduled, and called via the Apify API, JavaScript/Python clients, or integrations (Make, Zapier, n8n) — see the API tab on the Actor's page.

# Actor input Schema

## `searchStrings` (type: `array`):

What you'd type into the Naver Maps search bar, e.g. 삼겹살 (pork BBQ), 카페 (cafe). Korean terms match best. One term per line.

## `locationQuery` (type: `string`):

Free-text area to search within, e.g. "Gangnam, Seoul" or "강남구". Resolved to a bounding box via OpenStreetMap, then tiled to exceed Naver's 300-results-per-query cap. Leave empty for a plain keyword search (hard-capped at 300).

## `province` (type: `string`):

Korea's top administrative tier (시/도) — a special/metropolitan city or a province. e.g. "Seoul" (서울특별시), "Busan" (부산광역시), "Gyeonggi-do" (경기도).

## `municipality` (type: `string`):

Korea's municipal tier (시/군/구) — a district (구), city (시) or county (군), all the same level. e.g. "Gangnam-gu" (강남구), "Suwon-si" (수원시), "Yangpyeong-gun" (양평군).

## `neighborhood` (type: `string`):

Korea's sub-municipal tier (읍/면/동) — a neighborhood (동), town (읍) or township (면). e.g. "Yeoksam-dong" (역삼동).

## `postalCode` (type: `string`):

5-digit Korean postal code (우편번호). e.g. "06236".

## `customBounds` (type: `array`):

Exact bounding box as \[minLng, minLat, maxLng, maxLat]. Highest priority — overrides both 📍 Location and the structured fields when set. Coordinate order is longitude first.

## `placeUrls` (type: `array`):

Scrape specific places directly instead of searching. Paste Naver Maps place URLs — e.g. https://map.naver.com/p/entry/place/1005495070 — or naver.me share links (resolved automatically). When any URL or place ID is given, the search term and search area above are ignored (direct input takes priority). Each place is fetched with full details.

## `placeIds` (type: `array`):

Raw numeric Naver place IDs (e.g. 1005495070) — the number at the end of a place URL. Combined with any URLs above.

## `maxPlacesPerSearch` (type: `integer`):

Upper bound on unique places collected per search term (across all tiles). Set high with a Location to sweep an entire area.

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

Response language for place details.

## `scrapeDetails` (type: `boolean`):

Fetch each place's detail record: virtual phone, conveniences, business hours, full menu (name/price/description/images) and review totals. Adds one request per place.

## `maxReviewsPerPlace` (type: `integer`):

When Scrape place detail pages is on, include up to this many visitor reviews and blog reviews per place (full text, rating, dates). 0 = review totals only, no review bodies.

## Actor input object example

```json
{
  "searchStrings": [
    "삼겹살",
    "카페"
  ],
  "locationQuery": "Gangnam, Seoul",
  "province": "Seoul",
  "municipality": "Gangnam-gu",
  "customBounds": [
    127.02,
    37.49,
    127.07,
    37.52
  ],
  "placeUrls": [
    "https://map.naver.com/p/entry/place/1005495070"
  ],
  "placeIds": [
    "1005495070"
  ],
  "maxPlacesPerSearch": 100,
  "language": "ko",
  "scrapeDetails": false,
  "maxReviewsPerPlace": 0
}
```

# 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 = {
    "searchStrings": [
        "삼겹살"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hgservices/naver-maps-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 = { "searchStrings": ["삼겹살"] }

# Run the Actor and wait for it to finish
run = client.actor("hgservices/naver-maps-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 '{
  "searchStrings": [
    "삼겹살"
  ]
}' |
apify call hgservices/naver-maps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver Maps Scraper",
        "description": "Extract business/place data from thousands of Naver Maps locations and businesses (map.naver.com), including name, category, address, map coordinates, phone, opening hours, menus with prices and photos, amenities, payment info, visitor and blog reviews, review counts and rating score.",
        "version": "0.1",
        "x-build-id": "rzOOpXjZa7zjGaqtb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/hgservices~naver-maps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-hgservices-naver-maps-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-maps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-hgservices-naver-maps-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-maps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-hgservices-naver-maps-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": {
                    "searchStrings": {
                        "title": "🔍 Search term(s)",
                        "type": "array",
                        "description": "What you'd type into the Naver Maps search bar, e.g. 삼겹살 (pork BBQ), 카페 (cafe). Korean terms match best. One term per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationQuery": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "Free-text area to search within, e.g. \"Gangnam, Seoul\" or \"강남구\". Resolved to a bounding box via OpenStreetMap, then tiled to exceed Naver's 300-results-per-query cap. Leave empty for a plain keyword search (hard-capped at 300)."
                    },
                    "province": {
                        "title": "🗺 Province / Metropolitan city (시·도)",
                        "type": "string",
                        "description": "Korea's top administrative tier (시/도) — a special/metropolitan city or a province. e.g. \"Seoul\" (서울특별시), \"Busan\" (부산광역시), \"Gyeonggi-do\" (경기도)."
                    },
                    "municipality": {
                        "title": "🏙 City / County / District (시·군·구)",
                        "type": "string",
                        "description": "Korea's municipal tier (시/군/구) — a district (구), city (시) or county (군), all the same level. e.g. \"Gangnam-gu\" (강남구), \"Suwon-si\" (수원시), \"Yangpyeong-gun\" (양평군)."
                    },
                    "neighborhood": {
                        "title": "📍 Town / Neighborhood (읍·면·동)",
                        "type": "string",
                        "description": "Korea's sub-municipal tier (읍/면/동) — a neighborhood (동), town (읍) or township (면). e.g. \"Yeoksam-dong\" (역삼동)."
                    },
                    "postalCode": {
                        "title": "📮 Postal code (우편번호)",
                        "type": "string",
                        "description": "5-digit Korean postal code (우편번호). e.g. \"06236\"."
                    },
                    "customBounds": {
                        "title": "🛰 Custom search area",
                        "type": "array",
                        "description": "Exact bounding box as [minLng, minLat, maxLng, maxLat]. Highest priority — overrides both 📍 Location and the structured fields when set. Coordinate order is longitude first."
                    },
                    "placeUrls": {
                        "title": "🔗 Naver place URLs",
                        "type": "array",
                        "description": "Scrape specific places directly instead of searching. Paste Naver Maps place URLs — e.g. https://map.naver.com/p/entry/place/1005495070 — or naver.me share links (resolved automatically). When any URL or place ID is given, the search term and search area above are ignored (direct input takes priority). Each place is fetched with full details.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeIds": {
                        "title": "🆔 Naver place IDs",
                        "type": "array",
                        "description": "Raw numeric Naver place IDs (e.g. 1005495070) — the number at the end of a place URL. Combined with any URLs above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPlacesPerSearch": {
                        "title": "💯 Max places per search term",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Upper bound on unique places collected per search term (across all tiles). Set high with a Location to sweep an entire area.",
                        "default": 100
                    },
                    "language": {
                        "title": "🌍 Language",
                        "enum": [
                            "ko",
                            "en",
                            "ja",
                            "zh"
                        ],
                        "type": "string",
                        "description": "Response language for place details.",
                        "default": "ko"
                    },
                    "scrapeDetails": {
                        "title": "Scrape place detail pages (slower)",
                        "type": "boolean",
                        "description": "Fetch each place's detail record: virtual phone, conveniences, business hours, full menu (name/price/description/images) and review totals. Adds one request per place.",
                        "default": false
                    },
                    "maxReviewsPerPlace": {
                        "title": "Reviews per place",
                        "minimum": 0,
                        "type": "integer",
                        "description": "When Scrape place detail pages is on, include up to this many visitor reviews and blog reviews per place (full text, rating, dates). 0 = review totals only, no review bodies.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```