# Naver Map Local Business Scraper (`automation-lab/naver-map-local-business-scraper`) Actor

Scrape Naver Map places for Korean local business leads with addresses, websites, coordinates, review counts, status, images, and place URLs.

- **URL**: https://apify.com/automation-lab/naver-map-local-business-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Local Business Scraper

Extract Korean local business leads from public Naver Map search results.


### What does Naver Map Local Business Scraper do?

Naver Map Local Business Scraper extracts public place search results from map.naver.com.

It turns Korean local searches such as 서울 카페, 부산 호텔, or 강남 치과 into structured business records with names, categories, addresses, coordinates, websites, review counts, booking signals, photos, and Naver place URLs.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### Who is it for?

Use this actor if you build Korean lead lists, research local competitors, monitor reputation signals, map branch locations, enrich CRM accounts, or evaluate Korea market entry opportunities.

Agencies, sales teams, local SEO teams, hospitality analysts, and real estate researchers can all start from a keyword and export clean rows.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### Why use this Naver Map scraper?

Naver Map is a primary local discovery surface in Korea.

Generic global map datasets often miss Korean search context, Naver-specific place IDs, Naver booking labels, local review counts, and Korean address formats.

This actor focuses on those public Naver Map fields.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### What data can you extract?

Each dataset item represents one Naver Map place.

Fields include placeId, name, category, categories, address, roadAddress, phone, website, naverPlaceUrl, sourceQuery, rank, latitude, longitude, reviewCount, visitorReviewCount, blogReviewCount, businessStatus, menuInfo, thumbnailUrl, imageUrls, and booking or payment flags.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### How much does it cost to scrape Naver Map places?

The actor uses pay-per-event pricing: a small start event plus a per-place item event.

The default input is intentionally small so first runs stay cheap.

Larger lead generation runs scale with the number of unique places saved.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### How to scrape Naver Map search results

Add one or more Korean search queries, choose maxItems, keep includeDetails enabled for richer fields, and run the actor.

For best coverage, use multiple district/category queries such as 강남 카페, 홍대 카페, and 성수 카페 instead of one broad keyword.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### Input fields

queries is the main input.

searchUrls accepts copied Naver Map search URLs.

maxItems caps unique places across all searches.

includeDetails controls enrichment from the public place summary endpoint.

searchCoord sets the map center used when creating query URLs.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### Output fields

The default dataset view is optimized for local lead workflows.

Export to CSV, JSON, Excel, or API and join on placeId or naverPlaceUrl.

Coordinates are emitted as longitude and latitude when Naver provides them.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### Example use cases

Build a Seoul cafe lead list, map Busan hotel competitors, monitor dental clinic review totals by district, collect restaurant website links for outreach, or enrich existing Korean branch databases with Naver place IDs.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### Tips for better results

Use Korean search terms.

Split broad markets into district-level queries.

Keep maxItems realistic for the number of queries.

If one query returns fewer than expected, add adjacent neighborhoods or categories.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### Integrations

Connect the dataset to Google Sheets, Make, Zapier, CRM import jobs, geocoding workflows, BI dashboards, or local SEO monitoring pipelines.

The Naver place URL and placeId make deduplication straightforward.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### API usage

You can start runs with the Apify API using actor ID automation-lab/naver-map-local-business-scraper.

Pass JSON input with queries, maxItems, and includeDetails.

Fetch results from the default dataset items endpoint after the run succeeds.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### Node.js API example

Use the Apify client, call actor("automation-lab/naver-map-local-business-scraper").call({ queries: ["서울 카페"], maxItems: 50, includeDetails: true }), then read dataset items from the returned defaultDatasetId.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### Python API example

Use apify-client, call client.actor("automation-lab/naver-map-local-business-scraper").call(run_input={"queries":["부산 호텔"],"maxItems":40,"includeDetails":True}), then list dataset items.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### cURL API example

POST to https://api.apify.com/v2/acts/automation-lab~naver-map-local-business-scraper/runs with your token and a JSON body such as {"queries":["강남 치과"],"maxItems":50,"includeDetails":true}.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts


### MCP usage

Use the Apify MCP server with `?tools=automation-lab/naver-map-local-business-scraper` to run this actor from Claude Desktop or Claude Code.

```bash
claude mcp add apify --url "https://mcp.apify.com/?tools=automation-lab/naver-map-local-business-scraper"
````

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/naver-map-local-business-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 50 cafes from Naver Map for Seoul and group them by district."

- "Find Busan hotels on Naver Map and return websites plus review counts."

- "Build a dental clinic prospect list for Gangnam."

- ✅ Public Naver Map search results

- ✅ Korean local business lead generation

- ✅ Place URLs, coordinates, contacts, and review counts

### MCP prompt examples

Try: Scrape 50 cafes from Naver Map for Seoul and group them by district.

Or: Find Busan hotels on Naver Map and return websites plus review counts.

Or: Build a dental clinic prospect list for Gangnam.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts

### Legality and responsible use

This actor extracts publicly available Naver Map search data.

Use it responsibly, respect applicable laws and terms, avoid aggressive runs, and do not collect or process personal data unless you have a lawful basis.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts

### Limitations

Naver Map is a dynamic application.

The actor currently captures the public search result page returned by the Naver Map web app and enriches with public summary data.

Very broad searches may need multiple district-level queries.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts

### Troubleshooting

If you receive few results, use Korean terms and add nearby districts.

If a query has no results, check the spelling in Naver Map manually.

If details are missing, disable includeDetails to confirm the base search still returns records.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts

### Related scrapers

For adjacent workflows, check other automation-lab local business, maps, website contact, review, and directory scrapers on Apify.

Use this actor when the source of truth should specifically be Naver Map.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts

### Support

If a run fails, include the run URL, input, and expected query in your support message.

This helps reproduce Naver Map behavior quickly and keep extraction reliable.

- ✅ Public Naver Map search results
- ✅ Korean local business lead generation
- ✅ Place URLs, coordinates, contacts, and review counts

### FAQ

#### Why did my Naver Map query return fewer than maxItems?

Naver Map normally returns about 20 public places on the first loaded search page. Add more precise district/category queries such as `강남 카페`, `홍대 카페`, and `성수 카페` to collect more unique places.

#### Does this actor scrape private Naver accounts?

No. It only uses public Naver Map search and public place summary responses. It does not log in, use cookies, or access private user data.

#### Can I use copied Naver Map URLs?

Yes. Add copied `/p/search/` URLs to `searchUrls`, or just add Korean search terms to `queries` and let the actor build Naver Map search URLs for you.

### API Usage

Run the actor programmatically with the Apify API. Replace `MY_APIFY_TOKEN` with your token.

#### Node.js ApifyClient example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/naver-map-local-business-scraper').call({
  queries: ['서울 카페', '부산 호텔', '강남 치과'],
  maxItems: 60,
  includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.slice(0, 3));
```

#### Python ApifyClient example

```python
from apify_client import ApifyClient

client = ApifyClient('MY_APIFY_TOKEN')
run = client.actor('automation-lab/naver-map-local-business-scraper').call(run_input={
    'queries': ['서울 카페', '부산 호텔', '강남 치과'],
    'maxItems': 60,
    'includeDetails': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:3])
```

#### cURL example

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~naver-map-local-business-scraper/runs?token=MY_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["서울 카페","부산 호텔","강남 치과"],"maxItems":60,"includeDetails":true}'
```

### MCP setup for Claude

Use this actor from Claude through Apify MCP. The tool URL must include this actor slug:

```bash
claude mcp add apify-naver-map --url "https://mcp.apify.com/?tools=automation-lab/naver-map-local-business-scraper"
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-naver-map": {
      "url": "https://mcp.apify.com/?tools=automation-lab/naver-map-local-business-scraper"
    }
  }
}
```

Example MCP prompts:

- "Run the Naver Map scraper for 서울 카페 and summarize the top places by review count."
- "Create a Busan hotel competitor list from Naver Map with websites and coordinates."
- "Find dental clinics in Gangnam on Naver Map and return CRM-ready lead rows."

### MCP

Connect Claude to this actor with the Apify MCP server:

```bash
claude mcp add apify --url "https://mcp.apify.com/?tools=automation-lab/naver-map-local-business-scraper"
```

MCP JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/naver-map-local-business-scraper"
    }
  }
}
```

MCP example prompts:

- Use the Naver Map scraper to collect 20 Seoul cafe leads and rank them by review count.
- Run the Naver Map scraper for Busan hotels and return website URLs and coordinates.
- Scrape Gangnam dental clinics from Naver Map and make a CRM-ready CSV summary.

# Actor input Schema

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

Naver Map searches to run. Use Korean place/category phrases for best results, for example '서울 카페', '부산 호텔', or '강남 치과'.

## `searchUrls` (type: `array`):

Optional Naver Map /p/search URLs copied from your browser. These are processed in addition to queries.

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

Maximum unique Naver Map places to save across all queries. One search result page normally returns up to about 50 places.

## `includeDetails` (type: `boolean`):

Call Naver's public place summary endpoint for each place to enrich coordinates, labels, category, and address fields.

## `searchCoord` (type: `string`):

Longitude;latitude coordinate used as the map center when building query URLs. Default is central Seoul.

## `pageWaitMs` (type: `integer`):

Extra time for the Naver Map app to finish loading search data before extraction continues.

## Actor input object example

```json
{
  "queries": [
    "서울 카페"
  ],
  "searchUrls": [],
  "maxItems": 20,
  "includeDetails": true,
  "searchCoord": "126.97825;37.566551",
  "pageWaitMs": 2500
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "서울 카페"
    ],
    "searchUrls": [],
    "maxItems": 20,
    "includeDetails": true,
    "searchCoord": "126.97825;37.566551",
    "pageWaitMs": 2500
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/naver-map-local-business-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "queries": ["서울 카페"],
    "searchUrls": [],
    "maxItems": 20,
    "includeDetails": True,
    "searchCoord": "126.97825;37.566551",
    "pageWaitMs": 2500,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/naver-map-local-business-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "서울 카페"
  ],
  "searchUrls": [],
  "maxItems": 20,
  "includeDetails": true,
  "searchCoord": "126.97825;37.566551",
  "pageWaitMs": 2500
}' |
apify call automation-lab/naver-map-local-business-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver Map Local Business Scraper",
        "description": "Scrape Naver Map places for Korean local business leads with addresses, websites, coordinates, review counts, status, images, and place URLs.",
        "version": "0.1",
        "x-build-id": "hJA8OSK3BZlbXXXSJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~naver-map-local-business-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-naver-map-local-business-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/automation-lab~naver-map-local-business-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-naver-map-local-business-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/automation-lab~naver-map-local-business-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-naver-map-local-business-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Naver Map searches to run. Use Korean place/category phrases for best results, for example '서울 카페', '부산 호텔', or '강남 치과'.",
                        "default": [
                            "서울 카페"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "Naver Map search URLs",
                        "type": "array",
                        "description": "Optional Naver Map /p/search URLs copied from your browser. These are processed in addition to queries.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum places",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum unique Naver Map places to save across all queries. One search result page normally returns up to about 50 places.",
                        "default": 20
                    },
                    "includeDetails": {
                        "title": "Fetch place detail summaries",
                        "type": "boolean",
                        "description": "Call Naver's public place summary endpoint for each place to enrich coordinates, labels, category, and address fields.",
                        "default": true
                    },
                    "searchCoord": {
                        "title": "Search coordinate",
                        "type": "string",
                        "description": "Longitude;latitude coordinate used as the map center when building query URLs. Default is central Seoul.",
                        "default": "126.97825;37.566551"
                    },
                    "pageWaitMs": {
                        "title": "Wait after page load (ms)",
                        "minimum": 500,
                        "maximum": 15000,
                        "type": "integer",
                        "description": "Extra time for the Naver Map app to finish loading search data before extraction continues.",
                        "default": 2500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```