# Naver Map Scraper — Korean Places, Phone & Menus (`khadinakbar/naver-map-scraper`) Actor

Scrape Korean local businesses from Naver Map by keyword, category+location, or place URL/ID. Returns name, category, address, coordinates, phone, review counts, hours, and menus. HTTP-only, MCP-ready.

- **URL**: https://apify.com/khadinakbar/naver-map-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, MCP servers, Travel
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 place scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 — Korean Places, Phone, Reviews & Menus

**Scrape Korean local businesses from [Naver Map](https://map.naver.com) (네이버 지도) at scale.** Search by keyword, by category + location, or look up a specific place by URL/ID, and get a clean structured record for every business: **name, category, full address, GPS coordinates, phone number, review counts, business hours, images, and menus**. HTTP-only (no slow browser), MCP-ready for AI agents, and billed per result with no monthly subscription.

Naver Map is the dominant local-search platform in South Korea — the Korean equivalent of Google Maps. If you need Korean restaurant, cafe, salon, clinic, or shop data for lead generation, market research, or a location-based product, this Actor turns a search phrase into a spreadsheet.

### Why use Naver Map Scraper?

- **Lead generation in Korea** — build lists of restaurants, cafes, salons, or clinics with phone numbers and addresses for outreach.
- **Competitive & market research** — pull categories, review counts, ratings, and menus across a district or city.
- **Location intelligence** — every record carries latitude/longitude for mapping, geofencing, or store-density analysis.
- **AI agents / MCP** — a narrow query in, structured JSON out; ideal as a Claude/GPT tool call.
- **No subscription** — pay only for the places you actually scrape.

### How to use Naver Map Scraper

1. Open the **Input** tab.
2. Choose one of three ways to search:
   - **Search queries** — type Korean phrases like `강남 맛집` or `홍대 카페` (one list per query).
   - **Category + Location** — set a `Location` (e.g. `강남구`) and optional `Category` (e.g. `카페`).
   - **Place URLs or IDs** — paste `https://m.place.naver.com/restaurant/1188590985/home` or just `1188590985`.
3. Pick a **Place type** (restaurant covers food/cafes/bars/bakeries; beauty covers salons/nail/skincare).
4. Leave **Enrich with menus & details** on for full data, or turn it off for the fastest, cheapest list-only run.
5. Click **Start**. Results stream into the dataset — download as JSON, CSV, Excel, or HTML.

The default proxy is **Apify Residential pinned to South Korea (KR)** because Naver Map blocks non-Korean datacenter IPs. Keep this setting.

### Input

| Field | Type | Description |
|---|---|---|
| `searchQueries` | array | Free-text Naver searches, one place list per query (e.g. `강남 맛집`). |
| `placeType` | enum | `restaurant` (broadest — food/cafe/bar/bakery) or `beauty` (salon/nail/skincare). |
| `location` | string | Korean area/district for Category + Location mode (e.g. `강남구`). |
| `category` | string | Category keyword appended to `location` (e.g. `카페`). |
| `startUrls` | array | Naver place URLs or numeric IDs for single-place lookups. |
| `enrichDetails` | boolean | Add menus, images, and detail data per place (default `true`). |
| `maxPlaces` | integer | Hard cap on places scraped & billed (default `100`, max `2000`). |
| `proxyConfiguration` | object | Defaults to Residential + KR. Leave as-is. |

### Output

Each place is one dataset record:

```json
{
  "placeId": "2063685809",
  "name": "하프하우스",
  "businessType": "cafe",
  "category": "브런치카페",
  "phone": "02-508-7791",
  "roadAddress": "테헤란로1길 28-3 1, 2층",
  "fullAddress": "서울특별시 강남구 역삼동 825-26 강남역 KR 타워 1층, 2층",
  "commonAddress": "서울 강남구 역삼동",
  "latitude": 37.4968713,
  "longitude": 127.0295846,
  "visitorReviewScore": null,
  "blogReviewCount": 27,
  "totalReviewCount": 28,
  "businessHours": "매일 09:00 - 22:00",
  "options": ["단체 이용 가능", "포장", "예약", "무선 인터넷"],
  "thumbnailUrl": "https://ldb-phinf.pstatic.net/...jpg",
  "imageCount": 12,
  "hasNaverPay": false,
  "placeUrl": "https://m.place.naver.com/restaurant/2063685809/home",
  "naverMapUrl": "https://map.naver.com/p/entry/place/2063685809",
  "menu": [{ "name": "아메리카노", "price": "4500", "recommended": true }],
  "_enriched": true,
  "searchQuery": "강남 카페",
  "searchRank": 1,
  "scrapedAt": "2026-07-01T08:30:00.000Z"
}
````

You can download the dataset in JSON, CSV, Excel, or HTML.

### Data fields

| Field | Description |
|---|---|
| `placeId`, `name`, `businessType`, `category` | Identity + classification |
| `phone`, `virtualPhone` | Contact numbers |
| `roadAddress`, `address`, `commonAddress`, `fullAddress` | Addresses (road + jibun) |
| `latitude`, `longitude` | GPS coordinates |
| `visitorReviewScore`, `blogReviewCount`, `bookingReviewCount`, `totalReviewCount` | Review signals |
| `businessHours`, `options` | Hours + feature tags |
| `thumbnailUrl`, `imageCount`, `images` | Imagery |
| `hasBooking`, `bookingUrl`, `hasNaverPay`, `talktalkUrl` | Booking / payment / chat |
| `menu` | Menu items with price (enrichment) |
| `placeUrl`, `naverMapUrl` | Canonical links |
| `searchQuery`, `searchRank`, `scrapedAt` | Provenance |

### Pricing

This Actor uses **pay-per-event** pricing — no monthly subscription:

- **Place scraped** — $0.004 per place returned (base record).
- **Place enriched** — $0.006 per place when menus/details are added (only when enrichment succeeds).
- **Actor start** — $0.00005 per run.

A typical 100-place enriched run costs about **$1.00**. Turn off `enrichDetails` to pay only the base rate. Compute + proxy usage is also available as pay-per-usage for very large jobs.

### Tips & advanced options

- **Korean queries win.** Naver is a Korean service; `강남 카페` returns far more than "Gangnam cafe".
- **One keyword search returns ~50–70 places** (Naver's server-rendered ceiling). Split a city into districts/neighborhoods to go deeper.
- **Match `placeType` to intent** — search `강남 미용실` (hair salon) with `beauty`; food, cafes, and bars all use `restaurant`.
- **Cut cost** by turning off enrichment when you only need contact + location data.

### FAQ, limitations & support

**Is scraping Naver Map legal?** This Actor collects only publicly available business listing data. You are responsible for complying with Naver's Terms of Service and applicable laws (including privacy regulations such as PIPA/GDPR) when using the data. Do not use it to collect personal data without a lawful basis.

**Why do some places lack a phone or menu?** Naver does not publish every field for every business. Missing fields are returned as `null`, and enrichment degrades gracefully (`_enriched: false` with `_warnings`) if Naver's detail API is unavailable for a place.

**Why Korea-only proxies?** Naver Map blocks foreign datacenter IPs. Residential + KR is required for reliable results and is the default.

**Found a bug or need a field added?** Open the **Issues** tab. Custom Korean-data scraping solutions are available on request.

***

*This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by NAVER Corporation.*

# Actor input Schema

## `searchQueries` (type: `array`):

Free-text Naver Map searches, one place list per query (e.g. "강남 맛집", "홍대 카페", "Gangnam hair salon"). Korean queries return the richest results because Naver Map is a Korean service. Leave empty if you are using the Category + Location fields or Place URLs instead. This is NOT a place URL — put URLs in the Place URLs field.

## `placeType` (type: `string`):

Which Naver category route to search. "restaurant" is the broadest and covers food, cafes, bakeries, bars, and desserts — use it for most keyword searches. Pick "beauty" for hair salons, nail, and skincare. Applies to Search queries and Category + Location; ignored for Place URLs.

## `location` (type: `string`):

A Korean area, district, or landmark to search within (e.g. "강남구", "제주도", "Seoul Hongdae"). Combined with the Category field and Place type into one Naver search. Leave empty if you already provide full Search queries. Example: "성수동".

## `category` (type: `string`):

A category or business keyword appended to Location, such as "카페", "치과", "pilates". Only used when Location is set. Leave empty to search the Location alone. Example: "치과".

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

Direct Naver place URLs or numeric place IDs to look up individually (e.g. "https://m.place.naver.com/restaurant/1188590985/home" or "1188590985"). Each returns one place record with best-effort menu/detail enrichment. Use this for single-place lookups; use Search queries for discovery. naver.me short links cannot be resolved — paste the expanded URL.

## `enrichDetails` (type: `boolean`):

When on, each place is enriched via Naver's place API with menus (name + price), extra images, and amenities on top of the always-returned base record. Adds a small per-place charge and a little run time. Turn off for the fastest, cheapest list-only scrape. Enrichment is best-effort and degrades gracefully if Naver blocks the detail API.

## `maxPlaces` (type: `integer`):

Hard cap on total places scraped (and billed) across all queries and URLs in this run. Prevents runaway cost. Defaults to 100; maximum 2000. One Naver keyword search server-renders roughly 50-70 places.

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

Proxy settings. Naver Map is geo-sensitive and blocks non-Korean datacenter IPs, so this defaults to Apify Residential proxies pinned to South Korea (KR). Leave the default unless you know what you are doing — changing it usually lowers success rate.

## Actor input object example

```json
{
  "searchQueries": [
    "강남 맛집",
    "성수동 카페"
  ],
  "placeType": "restaurant",
  "location": "강남구",
  "category": "카페",
  "startUrls": [
    "https://m.place.naver.com/restaurant/1188590985/home",
    "1188590985"
  ],
  "enrichDetails": true,
  "maxPlaces": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "KR"
  }
}
```

# Actor output Schema

## `places` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQueries": [
        "강남 맛집"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "KR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "searchQueries": ["강남 맛집"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "KR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "searchQueries": [
    "강남 맛집"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "KR"
  }
}' |
apify call khadinakbar/naver-map-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver Map Scraper — Korean Places, Phone & Menus",
        "description": "Scrape Korean local businesses from Naver Map by keyword, category+location, or place URL/ID. Returns name, category, address, coordinates, phone, review counts, hours, and menus. HTTP-only, MCP-ready.",
        "version": "0.1",
        "x-build-id": "7D9tvoaqrkatzJcyV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~naver-map-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~naver-map-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~naver-map-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Free-text Naver Map searches, one place list per query (e.g. \"강남 맛집\", \"홍대 카페\", \"Gangnam hair salon\"). Korean queries return the richest results because Naver Map is a Korean service. Leave empty if you are using the Category + Location fields or Place URLs instead. This is NOT a place URL — put URLs in the Place URLs field.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "placeType": {
                        "title": "Place type / category route",
                        "enum": [
                            "restaurant",
                            "beauty"
                        ],
                        "type": "string",
                        "description": "Which Naver category route to search. \"restaurant\" is the broadest and covers food, cafes, bakeries, bars, and desserts — use it for most keyword searches. Pick \"beauty\" for hair salons, nail, and skincare. Applies to Search queries and Category + Location; ignored for Place URLs.",
                        "default": "restaurant"
                    },
                    "location": {
                        "title": "Location (for Category + Location mode)",
                        "type": "string",
                        "description": "A Korean area, district, or landmark to search within (e.g. \"강남구\", \"제주도\", \"Seoul Hongdae\"). Combined with the Category field and Place type into one Naver search. Leave empty if you already provide full Search queries. Example: \"성수동\"."
                    },
                    "category": {
                        "title": "Category keyword (optional, pairs with Location)",
                        "type": "string",
                        "description": "A category or business keyword appended to Location, such as \"카페\", \"치과\", \"pilates\". Only used when Location is set. Leave empty to search the Location alone. Example: \"치과\"."
                    },
                    "startUrls": {
                        "title": "Place URLs or IDs",
                        "type": "array",
                        "description": "Direct Naver place URLs or numeric place IDs to look up individually (e.g. \"https://m.place.naver.com/restaurant/1188590985/home\" or \"1188590985\"). Each returns one place record with best-effort menu/detail enrichment. Use this for single-place lookups; use Search queries for discovery. naver.me short links cannot be resolved — paste the expanded URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "enrichDetails": {
                        "title": "Enrich with menus & details",
                        "type": "boolean",
                        "description": "When on, each place is enriched via Naver's place API with menus (name + price), extra images, and amenities on top of the always-returned base record. Adds a small per-place charge and a little run time. Turn off for the fastest, cheapest list-only scrape. Enrichment is best-effort and degrades gracefully if Naver blocks the detail API.",
                        "default": true
                    },
                    "maxPlaces": {
                        "title": "Max places",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Hard cap on total places scraped (and billed) across all queries and URLs in this run. Prevents runaway cost. Defaults to 100; maximum 2000. One Naver keyword search server-renders roughly 50-70 places.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Naver Map is geo-sensitive and blocks non-Korean datacenter IPs, so this defaults to Apify Residential proxies pinned to South Korea (KR). Leave the default unless you know what you are doing — changing it usually lowers success rate.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "KR"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```