# Japan Job Market & Wage Stats — Hello Work Public Jobs (`jpmarketdata/japan-public-jobs-market-checker`) Actor

Japan's public job board (Hello Work, 1.13M live openings) in one call: exact opening count per keyword x prefecture, wage medians & quartiles split hourly/daily/monthly, how wide the advertised pay range is, employment-type mix, top cities. From $0.02 — no subscription. ハローワークの求人相場を1コールで。

- **URL**: https://apify.com/jpmarketdata/japan-public-jobs-market-checker.md
- **Developed by:** [h ichi](https://apify.com/jpmarketdata) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 job market analyzeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Japan Job Market & Wage Stats — Hello Work Public Jobs

**What does a nurse in Kochi actually get paid? How many engineering jobs are open in Osaka right now? How much room is there between the advertised minimum and maximum salary?** One call answers it, from Japan's national public job board.

This Actor queries **Hello Work / ハローワークインターネットサービス** ([www.hellowork.mhlw.go.jp](https://www.hellowork.mhlw.go.jp)), the job board of Japan's public employment service, run by the Ministry of Health, Labour and Welfare — **~1,130,000 live openings**, roughly **20x the largest private Japanese job board**, covering every prefecture, every industry and every company size, including the small and rural employers that never appear on commercial sites.

There is **no open API**: the ministry's XML feed is restricted to local governments and licensed employment agencies. For everyone else this Actor is the access path — and it returns statistics, not a pile of listings.

### Why this data is different: wages are a *structured range*

Japanese job ads are famous for free-text salaries ("月給29万1230円＋皆勤手当1万円"). Hello Work is the exception: every posting carries a machine-readable **`225,500円 〜 282,100円`** pair. That means this Actor can report something no other Japanese job source can:

- **`medianRangeWidth`** — how wide the advertised band is, i.e. **how much negotiation headroom** a role has in that market
- **`fixedWageShare`** — the share of employers offering a single fixed number (no headroom at all)
- clean **hourly / daily / monthly** medians and quartiles instead of one meaningless blended figure

### What you get per keyword × prefecture (one record)

| Field | Meaning |
|---|---|
| `totalOpenings` | **Exact count** of live openings for that keyword in that prefecture — a labour-demand indicator in its own right, not a sample estimate |
| `wages.hourly` / `wages.daily` / `wages.monthly` | `n`, `median`, `p25`, `p75`, `min`, `max` of the advertised **starting** wage, plus `medianUpper`, **`medianRangeWidth`** and `fixedWageShare` |
| `wages.annualFromMonthly` | Monthly median × 12, as a floor (bonuses are not published in the list view) |
| `employmentTypeBreakdown` | 正社員 (permanent) vs 正社員以外 (non-regular) vs パート (part-time) vs dispatched, with shares |
| `topMunicipalities` | Where inside the prefecture the jobs actually are (top 5 cities/wards) |
| `acceptedDateRange` / `deadlineDateRange` | How fresh the postings are and how long they stay open |
| `confidence` | `high`, or `medium` when the pay-period inference is not clean-cut |

Optionally, every sampled posting as its own record (job number, occupation, employer, location, wage range, dates).

**Privacy:** only employer (company) names are collected. Contact names and phone numbers are never parsed and never emitted.

### Pricing — from $0.02, no subscription

| Event | Price | When |
|---|---|---|
| Market summary | **$0.02** | Per keyword × prefecture analyzed |
| Individual job posting | **$0.002** | Only if you enable **Include individual job postings** |

A default run (1 keyword, 1 prefecture) costs **$0.02** and takes about 4 seconds. Combinations that return zero openings are never charged.

### Input

| Field | Example | Notes |
|---|---|---|
| `keywords` | `["看護師"]`, `["engineer","経理"]` | Occupation, skill, qualification or employer. Japanese matches best. **Required** |
| `prefectures` | `["13"]`, `["Tokyo","Kochi"]`, `["東京都"]`, `["all"]` | JIS codes, English names or Japanese names — all accepted. `"all"` = 47 prefectures |
| `jobCategory` | `"1"` | `1` = general openings (一般), `4` = seasonal migrant work (出稼ぎ) |
| `maxPagesPerSlice` | `2` | 30 jobs per page, 1–5 pages = up to 150 sampled jobs. Does not affect `totalOpenings` |
| `includeIndividualJobs` | `false` | Enable to also get each sampled posting as a record |
| `convertToUsd` | `false` | Adds a USD copy of every wage statistic |

Cost and time scale with `keywords × prefectures`. Keep a run to a handful of combinations; the Actor keeps a soft 95-second budget and flags any record it had to truncate with `truncatedForTimeLimit`.

#### Exact vs sampled — which is which

| Field | Basis |
|---|---|
| `totalOpenings` | **Exact** — the site's own result count for the query |
| everything else | Sampled from the newest `maxPagesPerSlice × 30` postings |

Hello Work serves a **fixed 30 results per page in newest-first order**, and neither the page size nor the sort order can be changed over HTTP. So the sample is **the most recently posted openings**, not a random draw — which is exactly what you want for a "what is the market paying *right now*" read, and exactly what you must not treat as a stratified sample of the whole stock. Every record states this in `sampleBasis: "newest-first"` and `estimatedFrom.method`.

### Output example (abridged; Kochi × 看護師, measured 2026-07-25)

```json
{
  "type": "job_market_summary",
  "keyword": "看護師",
  "prefecture": "Kochi",
  "prefectureNameJa": "高知県",
  "prefectureCode": "39",
  "jobCategory": "1",
  "totalOpenings": 615,
  "sampledJobs": 60,
  "sampledPages": 2,
  "sampleBasis": "newest-first",
  "wages": {
    "hourly":  {"n": 12, "median": 1277, "p25": 1150, "p75": 1400, "min": 1030,
                "max": 1800, "medianUpper": 1377, "medianRangeWidth": 100,
                "fixedWageShare": 0.25},
    "daily":   {"n": 0, "median": null, "medianRangeWidth": null},
    "monthly": {"n": 48, "median": 225500, "p25": 198000, "p75": 268000,
                "min": 170000, "max": 420000, "medianUpper": 282100,
                "medianRangeWidth": 56600, "fixedWageShare": 0.08},
    "annualFromMonthly": {"n": 48, "median": 2706000,
                          "note": "Monthly lower bound x 12. Bonuses ..."}
  },
  "employmentTypeBreakdown": [
    {"employmentType": "正社員", "name": "Permanent employee (seishain)", "jobs": 38, "share": 0.6333},
    {"employmentType": "正社員以外", "name": "Non-regular full-time employee", "jobs": 14, "share": 0.2333},
    {"employmentType": "パート労働者", "name": "Part-time worker", "jobs": 8, "share": 0.1333}
  ],
  "topMunicipalities": [{"municipality": "高知市", "jobs": 31}, {"municipality": "南国市", "jobs": 6}],
  "acceptedDateRange": {"newest": "2026-07-24", "oldest": "2026-07-11"},
  "deadlineDateRange": {"nearest": "2026-08-31", "farthest": "2026-10-31"},
  "currency": "JPY",
  "confidence": "high",
  "checkedAt": "2026-07-25T09:00:00+00:00",
  "sourceUrl": "https://www.hellowork.mhlw.go.jp/kensaku/GECA110010.do?action=searchBtn&..."
}
````

With `includeIndividualJobs: true` you additionally get, per posting:

```json
{
  "type": "job",
  "jobNumber": "38010-24578261",
  "occupation": "看護職員（デイサービス）",
  "employerName": "株式会社 ツクイ 中国・四国圏",
  "workLocation": "高知県高知市",
  "municipality": "高知市",
  "employmentType": "正社員",
  "wageLow": 225500, "wageHigh": 282100, "wageRangeWidth": 56600,
  "wageType": "monthly",
  "acceptedDate": "2026-07-24", "deadlineDate": "2026-09-30"
}
```

### Use cases

- **International recruiters & relocation firms** — benchmark what a role really pays in a given prefecture before quoting a candidate, including the negotiation band
- **HR & compensation teams** — a live, free-of-survey-fees external salary benchmark for Japan, per occupation and per region
- **HR-tech / job-board products** — salary-range widgets and "jobs open near you" counts without licensing a private board
- **Labour-market analysts, economists, policy & regional research** — openings per keyword per prefecture is a demand series you can run weekly; the newest-first sample doubles as a flow (new postings) measure
- **Site selection & expansion planning** — is there a hiring pool for welders / caregivers / drivers in this prefecture, and at what price
- **Staffing & franchise operators** — compare your offer against the local Hello Work median before posting

### Notes & limits

- **The sample is newest-first, always.** 30 results per page is fixed and the sort order cannot be changed over HTTP. Read the wage stats as "what is being advertised right now", not as a census of all live postings
- **Pay periods are inferred from magnitude**, because the list view prints wages without a period label: `< 10,000` = hourly, `10,000–99,999` = daily, `>= 100,000` = monthly. Daily-paid postings are rare (0 of 30 in the measured sample) but when any appear, `confidence` drops to `medium`
- `annualFromMonthly` **excludes bonuses** (賞与), overtime and most allowances — Japanese packages often add 2–5 months of salary in bonuses, so treat it as a floor
- Jobs are filtered by **work location**, not by employer head office
- Keyword matching is Hello Work's own free-word search; broad English keywords will match fewer postings than the Japanese equivalent
- Read-only, throttled to one request per 1.5 s out of respect for a government system. No login, no personal data, nothing stored between runs
- The postings are the employers' own text, published by a public agency; this Actor computes statistics from them on demand and keeps no database

***

### 日本語ガイド

**ハローワークインターネットサービス(厚生労働省)の公開求人を、1コールで「キーワード × 都道府県」の求人市場統計にして返す Actor です。**

- **概要**: 指定したキーワード(職種名・資格名など)と都道府県について、**有効求人件数(実数)** と **賃金統計** を返します。ハローワークは求人約113万件と国内最大の母数を持ち、しかも賃金が「225,500円〜282,100円」という**数値レンジ**で構造化されているため、民間求人サイトでは作れない統計が作れます。
- **一番の売り**: **賃金レンジの幅(`medianRangeWidth`)**。「その職種・その地域では、下限と上限の差が中央値でいくらか」= **交渉余地の指標**です。あわせて固定給(下限=上限)の割合 `fixedWageShare` も返します。賃金は **時給 / 日給 / 月給** を桁で判別して別々に集計するので、混ぜた無意味な平均になりません。
- **使い方**: `keywords` に職種などを指定(日本語が最も精度が高い)、`prefectures` に都道府県を指定します(**JISコード `13` / 日本語 `東京都` / 英語 `Tokyo` のいずれでも可**。`["all"]` で47都道府県)。標本を増やしたい場合は `maxPagesPerSlice` を上げてください(1ページ30件固定・最大5ページ=150件)。個別求人が必要なときだけ `includeIndividualJobs` を ON にします。
- **料金**: 「キーワード×都道府県」1組の市場サマリーが **$0.02**、個別求人レコードは **$0.002/件**(既定 OFF なので既定実行は $0.02 固定)。**0件の組み合わせには課金されません**。サブスクリプション不要です。
- **実数とサンプルの区別**: `totalOpenings`(有効求人件数)は**サイトが返す実数**です。賃金・雇用形態・市区町村などは**新着順の先頭 N ページ**からの標本です。ハローワークは**表示件数30件固定・並び順の変更が HTTP からはできない**ため、標本は常に「直近に登録された求人」になります。この点は全レコードに `sampleBasis: "newest-first"` として明記しています。
- **注意点**: 一覧に賃金形態(時給/日給/月給)のラベルは無く、**下限額の桁数から判定**しています(1万円未満=時給、1万〜9万円台=日給、10万円以上=月給)。日給帯が出現した場合は `confidence` を `medium` に下げます。月給×12 の年収換算は**賞与を含みません**。
- **個人情報**: 取得するのは**事業所名(法人名)まで**です。担当者名・電話番号は取得しません。政府システムへの負荷に配慮し、リクエスト間隔は 1.5 秒以上あけています。

# Actor input Schema

## `keywords` (type: `array`):

Job keywords to analyze — occupation, skill, employer or qualification. Japanese keywords match best (看護師, 介護, 経理, 溶接, 保育士); English words also work for IT/international roles. Each keyword x prefecture combination costs $0.02.

## `prefectures` (type: `array`):

One or more prefectures. Accepts JIS codes (13, 27, 39), English names (Tokyo, Osaka, Kochi) or Japanese names (東京都, 大阪府). Use \["all"] for all 47 prefectures — note that costs $0.02 per prefecture and needs several runs to fit the time budget.

## `jobCategory` (type: `string`):

Hello Work's 求人区分. 'General' covers ordinary full-time and part-time openings (the vast majority). 'Seasonal migrant work' (出稼ぎ) is a small, separate register.

## `maxPagesPerSlice` (type: `integer`):

Hello Work returns a fixed 30 jobs per page, so 2 pages = up to 60 sampled jobs per combination. More pages give steadier wage medians but add ~2 seconds each. The total opening count is exact regardless of this setting.

## `includeIndividualJobs` (type: `boolean`):

Off by default: a run costs a flat $0.02 per keyword x prefecture summary. Enable to also get every sampled posting (job number, occupation, employer, location, wage range, dates) at +$0.002 per job. Contact names and phone numbers are never collected.

## `convertToUsd` (type: `boolean`):

Adds a USD copy of every wage statistic plus the exchange rate used. Wages are always reported in JPY as well.

## Actor input object example

```json
{
  "keywords": [
    "看護師"
  ],
  "prefectures": [
    "13"
  ],
  "jobCategory": "1",
  "maxPagesPerSlice": 2,
  "includeIndividualJobs": false,
  "convertToUsd": false
}
```

# 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 = {
    "keywords": [
        "看護師"
    ],
    "prefectures": [
        "13"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/japan-public-jobs-market-checker").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 = {
    "keywords": ["看護師"],
    "prefectures": ["13"],
}

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/japan-public-jobs-market-checker").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 '{
  "keywords": [
    "看護師"
  ],
  "prefectures": [
    "13"
  ]
}' |
apify call jpmarketdata/japan-public-jobs-market-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=jpmarketdata/japan-public-jobs-market-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Japan Job Market & Wage Stats — Hello Work Public Jobs",
        "description": "Japan's public job board (Hello Work, 1.13M live openings) in one call: exact opening count per keyword x prefecture, wage medians & quartiles split hourly/daily/monthly, how wide the advertised pay range is, employment-type mix, top cities. From $0.02 — no subscription. ハローワークの求人相場を1コールで。",
        "version": "0.1",
        "x-build-id": "MKBsqMtrXCH1RqHgz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jpmarketdata~japan-public-jobs-market-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jpmarketdata-japan-public-jobs-market-checker",
                "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/jpmarketdata~japan-public-jobs-market-checker/runs": {
            "post": {
                "operationId": "runs-sync-jpmarketdata-japan-public-jobs-market-checker",
                "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/jpmarketdata~japan-public-jobs-market-checker/run-sync": {
            "post": {
                "operationId": "run-sync-jpmarketdata-japan-public-jobs-market-checker",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Job keywords to analyze — occupation, skill, employer or qualification. Japanese keywords match best (看護師, 介護, 経理, 溶接, 保育士); English words also work for IT/international roles. Each keyword x prefecture combination costs $0.02.",
                        "default": [
                            "看護師"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "prefectures": {
                        "title": "Prefectures",
                        "type": "array",
                        "description": "One or more prefectures. Accepts JIS codes (13, 27, 39), English names (Tokyo, Osaka, Kochi) or Japanese names (東京都, 大阪府). Use [\"all\"] for all 47 prefectures — note that costs $0.02 per prefecture and needs several runs to fit the time budget.",
                        "default": [
                            "13"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobCategory": {
                        "title": "Job category",
                        "enum": [
                            "1",
                            "4"
                        ],
                        "type": "string",
                        "description": "Hello Work's 求人区分. 'General' covers ordinary full-time and part-time openings (the vast majority). 'Seasonal migrant work' (出稼ぎ) is a small, separate register.",
                        "default": "1"
                    },
                    "maxPagesPerSlice": {
                        "title": "Result pages sampled per keyword x prefecture",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Hello Work returns a fixed 30 jobs per page, so 2 pages = up to 60 sampled jobs per combination. More pages give steadier wage medians but add ~2 seconds each. The total opening count is exact regardless of this setting.",
                        "default": 2
                    },
                    "includeIndividualJobs": {
                        "title": "Include individual job postings",
                        "type": "boolean",
                        "description": "Off by default: a run costs a flat $0.02 per keyword x prefecture summary. Enable to also get every sampled posting (job number, occupation, employer, location, wage range, dates) at +$0.002 per job. Contact names and phone numbers are never collected.",
                        "default": false
                    },
                    "convertToUsd": {
                        "title": "Also report wages in USD",
                        "type": "boolean",
                        "description": "Adds a USD copy of every wage statistic plus the exchange rate used. Wages are always reported in JPY as well.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
