# Naver DataLab Search Trends Scraper (`automation-lab/naver-datalab-search-trends-scraper`) Actor

Compare Korean keyword demand over time with typed Naver DataLab ratios, audience filters, and export-ready time series.

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

## Pricing

from $0.02 / 1,000 trend point extracteds

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 DataLab Search Trends Scraper

Compare Korean search demand over time with structured data from public Naver DataLab trend charts.

This Apify Actor turns keyword groups, audience filters, and date ranges into export-ready time series. It returns one row per keyword group and period, including Naver’s normalized interest ratio and every filter used.

Use it to monitor brands, validate product seasonality, plan Korean content, or feed recurring search-demand dashboards—without manually downloading spreadsheets from DataLab.

### What does Naver DataLab Search Trends Scraper do?

The Actor automates the public **검색어트렌드** workflow on Naver DataLab.

It can:

- compare up to five keyword groups in one run;
- combine up to 20 spelling variants or related terms per group;
- select daily, weekly, or monthly periods;
- filter by mobile or PC searches;
- filter by gender and Naver age bands;
- preserve all query dimensions on every output row;
- export results as JSON, CSV, Excel, XML, or RSS through Apify.

Values are normalized interest ratios, not absolute search volumes. A value of `100` is the highest observed point in the selected comparison and period.

### Who is it for?

#### Korean SEO agencies

Compare client brands and non-brand terms, identify seasonality, and send recurring reports to Looker Studio or a warehouse.

#### Ecommerce and retail teams

Track category interest before promotions, compare product naming variants, and find the best launch window.

#### Content and localization studios

Validate Korean terminology, compare translated phrases, and prioritize editorial calendars using local search behavior.

#### Market researchers

Measure relative attention around launches, events, competitors, or public topics with consistent filters.

#### Data teams

Schedule repeat runs and ingest normalized time series through the Apify API, webhooks, Zapier, Make, Google Sheets, or MCP.

### Why use this Actor?

Manual DataLab downloads work for one-off checks, but recurring comparisons require repeated form entry, spreadsheet cleanup, and filter documentation.

This Actor provides:

- reproducible inputs;
- typed records;
- explicit source URLs;
- automation-friendly output;
- timestamps for auditability;
- scheduled execution on Apify.

### Input

The primary input is `keywordGroups`.

Each group has:

- `name`: a short label displayed in output;
- `keywords`: one to 20 terms that Naver combines into the group series.

Optional controls include `startDate`, `endDate`, `timeUnit`, `device`, `gender`, `ages`, and `proxyConfiguration`.

```json
{
  "keywordGroups": [
    { "name": "ChatGPT", "keywords": ["챗GPT", "ChatGPT"] },
    { "name": "Clova X", "keywords": ["클로바X", "하이퍼클로바"] }
  ],
  "startDate": "2026-01-01",
  "endDate": "2026-06-30",
  "timeUnit": "week",
  "device": "mo",
  "gender": "",
  "ages": []
}
````

### Keyword group design

Group spelling variations when they represent the same topic.

For example, a group named `Camping` might contain `캠핑`, `Camping`, `캠핑용품`, and `캠핑장`.

Keep competing concepts in separate groups so their ratios can be compared.

Naver supports at most five groups and 20 keywords per group. The Actor validates these limits before opening a browser.

### Date ranges and time units

Use ISO dates in `YYYY-MM-DD` format.

Naver DataLab supports data from January 2016 onward. Recent daily data can lag by approximately one day.

Choose:

- `date` for daily points;
- `week` for weekly summaries;
- `month` for long-term seasonality.

Weekly or monthly data is usually better for multi-year dashboards and produces fewer records.

### Audience filters

`device` accepts all devices, mobile, or PC.

`gender` accepts all, female, or male.

`ages` accepts Naver’s age-band codes from `1` through `11`. Leave it empty to include all ages.

Every emitted item repeats the chosen audience dimensions so exports remain self-describing.

### Output data

One dataset item represents one keyword group in one period.

| Field | Type | Meaning |
|---|---|---|
| `keywordGroup` | string | User-defined group label |
| `keywords` | array | Terms combined in the group |
| `period` | string | Date, week, or month returned by Naver |
| `ratio` | number | Normalized interest from 0 to 100 |
| `timeUnit` | string | Daily, weekly, or monthly unit |
| `startDate` | string | Requested range start |
| `endDate` | string | Requested range end |
| `device` | string | All, mobile, or PC |
| `gender` | string | All, female, or male |
| `ages` | array | Selected age codes |
| `sourceUrl` | string | Naver result page |
| `scrapedAt` | string | UTC extraction timestamp |

### Output example

```json
{
  "keywordGroup": "ChatGPT",
  "keywords": ["챗GPT", "ChatGPT"],
  "period": "2026-06-22",
  "ratio": 64.23891,
  "timeUnit": "week",
  "startDate": "2026-01-01",
  "endDate": "2026-06-30",
  "device": "mobile",
  "gender": "all",
  "ages": [],
  "sourceUrl": "https://datalab.naver.com/keyword/trendResult.naver?hashKey=...",
  "scrapedAt": "2026-07-12T02:30:00.000Z"
}
```

### How to run it

1. Open the Actor input page.
2. Add one to five keyword groups.
3. Select the date range and time unit.
4. Optionally choose audience filters.
5. Click **Start**.
6. Open the Dataset tab to preview or export records.

Start with a short weekly range when testing a new group definition.

### How much does it cost to scrape Naver search trends?

The Actor uses pay-per-event pricing: a small run-start charge plus a charge for each dataset item.

The final Store price is shown on the Actor pricing tab before you start a run. Longer daily ranges and more groups create more items. Weekly and monthly units reduce item counts.

Apify free-plan credits can be used where available.

### Scheduling a trend monitor

Create an Apify schedule with a fixed input and run it weekly or monthly.

For stable dashboards:

- keep keyword group definitions unchanged;
- keep audience filters unchanged;
- store `scrapedAt` and `sourceUrl`;
- append new exports rather than overwriting historical snapshots.

Remember that ratios are normalized within each Naver comparison. Compare like-for-like runs.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/naver-datalab-search-trends-scraper').call({
  keywordGroups: [{ name: 'Running', keywords: ['러닝', '조깅'] }],
  startDate: '2026-01-01',
  endDate: '2026-06-30',
  timeUnit: 'week'
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/naver-datalab-search-trends-scraper').call(run_input={
    'keywordGroups': [{'name': 'Running', 'keywords': ['러닝', '조깅']}],
    'startDate': '2026-01-01',
    'endDate': '2026-06-30',
    'timeUnit': 'week',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~naver-datalab-search-trends-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keywordGroups":[{"name":"Running","keywords":["러닝","조깅"]}],"timeUnit":"week"}'
```

Use the returned dataset ID to download items through the Apify Dataset API.

### MCP integration

Connect the Actor to Claude through Apify MCP:

`https://mcp.apify.com/?tools=automation-lab/naver-datalab-search-trends-scraper`

Add it to Claude Code:

```bash
claude mcp add --transport http naver-trends "https://mcp.apify.com/?tools=automation-lab/naver-datalab-search-trends-scraper"
```

Claude Desktop or another JSON-based MCP client can use:

```json
{
  "mcpServers": {
    "naver-trends": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/naver-datalab-search-trends-scraper"
    }
  }
}
```

Example prompts:

- “Compare weekly Korean search interest for these three skincare brands.”
- “Create monthly Naver trend data for camping terms since 2020.”
- “Run the Naver trend scraper for mobile users and summarize the peaks.”

In Claude Code, add the URL as an HTTP MCP server. In Claude Desktop, configure the same endpoint in your MCP client settings.

### Integrations

#### Google Sheets

Use an Apify integration or Make scenario to append each completed dataset to a reporting sheet.

#### Looker Studio and warehouses

Export CSV/JSON to BigQuery, Snowflake, or an object store, then chart `period` against `ratio` by `keywordGroup`.

#### Slack alerts

Use a webhook to trigger downstream code when a run finishes and alert when the latest ratio changes materially.

#### Zapier and Make

Start the Actor from a campaign workflow, retrieve dataset items, and route them to dashboards or client reports.

### Data interpretation

Naver sets the maximum point in the selected comparison to 100. Ratios do not represent absolute query counts.

Changing groups, dates, devices, genders, or age bands changes the normalization base. Avoid joining ratios from differently configured runs without documenting the comparison.

A zero can indicate very low relative activity, not necessarily zero searches.

### Reliability and proxies

Direct public access is the default and avoids unnecessary proxy cost.

If Naver returns an access page from your environment, enable Apify Proxy and select South Korea. The Actor checks the page title and returns a clear error instead of emitting empty data.

Naver can change form fields or workbook layout. The extractor validates the workbook date header and fails visibly on unexpected formats.

### Limitations

- This Actor returns normalized ratios, not absolute search volume.
- It currently targets public Search Trends, not Shopping Insight rankings.
- Naver allows up to five groups and 20 terms per group.
- Very recent daily values may not yet be finalized.
- Geographic region within Korea is not a Search Trends filter.
- Results depend on Naver DataLab availability and methodology.

### Legality

The Actor accesses public Naver DataLab pages without logging in or bypassing private controls.

Use results in accordance with Naver’s terms, applicable laws, and your organization’s data policies. Do not use trend data to infer sensitive attributes about individuals. This Actor produces aggregate statistics only.

### Troubleshooting

#### The run says Naver returned an access page

Enable Apify Proxy and choose country `KR`. If the issue persists, retry later rather than launching many parallel sessions.

#### The run returns no trend points

Check keyword spelling, date range, and audience filters. Try a broader term and leave age/gender filters empty.

#### My ratios differ between runs

Confirm that the keyword groups, date range, time unit, and audience filters are identical. Ratios are normalized per comparison.

#### A daily point is missing

Naver notes that daily data is reflected after processing on the following day. Use an earlier end date for scheduled reports.

### Related actors

For location and local-business workflows, use [Naver Map Local Business Scraper](https://apify.com/automation-lab/naver-map-local-business-scraper).

Map listings and reviews are separate from DataLab search-interest time series. Choose this Actor when the goal is trend comparison rather than lead extraction.

### FAQ

#### Does the Actor need a Naver account?

No. It automates the public DataLab Search Trends page.

#### Does it use the official Naver Open API?

No API credential is required. The Actor follows the public website workflow and parses the downloadable result workbook.

#### Can I compare Korean and English spellings together?

Yes. Put equivalent spellings in one keyword group so Naver combines them.

#### Can I retrieve absolute monthly search volume?

No. Naver DataLab exposes normalized ratios for this workflow.

#### Can I export Excel?

Yes. Apify datasets can be downloaded as Excel, CSV, JSON, XML, or other supported formats.

#### Can I run it automatically?

Yes. Use Apify schedules, API calls, webhooks, Zapier, Make, or MCP.

#### What is the recommended time unit?

Use weekly for most monitoring, daily for campaign windows, and monthly for multi-year seasonality.

#### Are empty audience arrays valid?

Yes. An empty `ages` array means all age groups.

### Support

If a run fails, share the run URL and a non-sensitive copy of the input through the Actor’s Issues tab. Include whether direct access or Apify Proxy was used.

For reproducible help, keep the failed run’s logs and dataset available.

# Actor input Schema

## `keywordGroups` (type: `array`):

Each group combines up to 20 Korean or English search terms into one trend series.

## `startDate` (type: `string`):

First period, YYYY-MM-DD (Naver supports dates from 2016-01-01).

## `endDate` (type: `string`):

Last period, YYYY-MM-DD.

## `timeUnit` (type: `string`):

Aggregate trend points by day, week, or month.

## `device` (type: `string`):

Limit searches to mobile or PC, or include all devices.

## `gender` (type: `string`):

Limit searches by reported gender, or include all genders.

## `ages` (type: `array`):

Naver age codes: 1 (~12), 2 (13–18), 3 (19–24), through 11 (60+). Empty means all.

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

Optional. If direct access is blocked, use an Apify proxy and select South Korea.

## Actor input object example

```json
{
  "keywordGroups": [
    {
      "name": "AI tools",
      "keywords": [
        "챗GPT",
        "ChatGPT"
      ]
    },
    {
      "name": "Naver AI",
      "keywords": [
        "하이퍼클로바",
        "클로바X"
      ]
    }
  ],
  "startDate": "2026-01-01",
  "endDate": "2026-06-30",
  "timeUnit": "week",
  "device": "",
  "gender": "",
  "ages": []
}
```

# 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 = {
    "keywordGroups": [
        {
            "name": "AI tools",
            "keywords": [
                "챗GPT",
                "ChatGPT"
            ]
        },
        {
            "name": "Naver AI",
            "keywords": [
                "하이퍼클로바",
                "클로바X"
            ]
        }
    ],
    "startDate": "2026-01-01",
    "endDate": "2026-06-30",
    "timeUnit": "week"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/naver-datalab-search-trends-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 = {
    "keywordGroups": [
        {
            "name": "AI tools",
            "keywords": [
                "챗GPT",
                "ChatGPT",
            ],
        },
        {
            "name": "Naver AI",
            "keywords": [
                "하이퍼클로바",
                "클로바X",
            ],
        },
    ],
    "startDate": "2026-01-01",
    "endDate": "2026-06-30",
    "timeUnit": "week",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/naver-datalab-search-trends-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 '{
  "keywordGroups": [
    {
      "name": "AI tools",
      "keywords": [
        "챗GPT",
        "ChatGPT"
      ]
    },
    {
      "name": "Naver AI",
      "keywords": [
        "하이퍼클로바",
        "클로바X"
      ]
    }
  ],
  "startDate": "2026-01-01",
  "endDate": "2026-06-30",
  "timeUnit": "week"
}' |
apify call automation-lab/naver-datalab-search-trends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naver DataLab Search Trends Scraper",
        "description": "Compare Korean keyword demand over time with typed Naver DataLab ratios, audience filters, and export-ready time series.",
        "version": "0.1",
        "x-build-id": "apMOrupZjdpGlNTJ8"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~naver-datalab-search-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-naver-datalab-search-trends-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-datalab-search-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-naver-datalab-search-trends-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-datalab-search-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-naver-datalab-search-trends-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",
                "required": [
                    "keywordGroups"
                ],
                "properties": {
                    "keywordGroups": {
                        "title": "🔎 Keyword groups",
                        "minItems": 1,
                        "maxItems": 5,
                        "type": "array",
                        "description": "Each group combines up to 20 Korean or English search terms into one trend series.",
                        "items": {
                            "type": "object",
                            "required": [
                                "name",
                                "keywords"
                            ],
                            "properties": {
                                "name": {
                                    "type": "string",
                                    "title": "Group name",
                                    "description": "Label shown in the trend chart and output."
                                },
                                "keywords": {
                                    "type": "array",
                                    "title": "Keywords",
                                    "description": "Terms combined into this group.",
                                    "items": {
                                        "type": "string"
                                    },
                                    "minItems": 1,
                                    "maxItems": 20
                                }
                            }
                        },
                        "default": [
                            {
                                "name": "AI tools",
                                "keywords": [
                                    "챗GPT",
                                    "ChatGPT"
                                ]
                            }
                        ]
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "First period, YYYY-MM-DD (Naver supports dates from 2016-01-01)."
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Last period, YYYY-MM-DD."
                    },
                    "timeUnit": {
                        "title": "Time unit",
                        "enum": [
                            "date",
                            "week",
                            "month"
                        ],
                        "type": "string",
                        "description": "Aggregate trend points by day, week, or month.",
                        "default": "week"
                    },
                    "device": {
                        "title": "Device",
                        "enum": [
                            "",
                            "mo",
                            "pc"
                        ],
                        "type": "string",
                        "description": "Limit searches to mobile or PC, or include all devices.",
                        "default": ""
                    },
                    "gender": {
                        "title": "Gender",
                        "enum": [
                            "",
                            "f",
                            "m"
                        ],
                        "type": "string",
                        "description": "Limit searches by reported gender, or include all genders.",
                        "default": ""
                    },
                    "ages": {
                        "title": "Age bands",
                        "type": "array",
                        "description": "Naver age codes: 1 (~12), 2 (13–18), 3 (19–24), through 11 (60+). Empty means all.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional. If direct access is blocked, use an Apify proxy and select South Korea."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```