# Japan Tech Jobs Market Checker — Bilingual IT Salary Stats (`jpmarketdata/japan-tech-jobs-market-checker`) Actor

Salary stats for English-speaking / bilingual IT jobs in Japan (TokyoDev + JapanDev) in one call: advertised ¥M bands, how many roles disclose pay at all, band width, Japanese level, remote and residency mix. From $0.02. 日本のバイリンガルIT求人の給与レンジ統計を1コールで。一次调用获取日本双语IT职位薪资区间统计。

- **URL**: https://apify.com/jpmarketdata/japan-tech-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 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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Tech Jobs Market Checker — Bilingual IT Salary Stats

**What does an English-speaking tech job in Japan actually pay — and how many employers will even tell you?** One call answers both, across the two English-language Japanese job boards that publish salary bands.

Most Japanese job boards hide pay entirely. That is why the headline number here is not just the median: it is **`salaryDisclosureRate`** — how many of the live roles publish a band at all — next to **`salaryRangeWidthMillionsJpy`**, how wide that published `¥8M ~ ¥16M` band is. A wide band is negotiation headroom; a missing band is a market signal of its own.

### Overview

The Actor reads two job boards in one run and returns **one compact market record**:

- **`salaryMinMillionsJpy` / `salaryMaxMillionsJpy` / `salaryMidMillionsJpy`** — min / p25 / median / p75 / max / average of the advertised bands, in ¥ millions per year
- **`salaryRangeWidthMillionsJpy`** — the distribution of `max - min`. The width of the advertised band *is* the negotiation range
- **`salaryDisclosureRate`** — how many of the matched roles published a band at all
- **`salaryByJapaneseLevel`** — the money question: does requiring Japanese pay more? Count, median low and median high per required Japanese level
- **`japaneseRequirement`** — none / conversational / business / fluent / unknown
- **`residency`** — Japan residents only vs. can apply from abroad vs. unknown
- **`remote`**, **`categoryTop`**, **`companyCount`**
- Optionally every matching role as its own record

| Source | URL | What one request returns | Reported as |
|---|---|---|---|
| **TokyoDev** | `https://www.tokyodev.com/jobs` | **every** listed position, server-rendered, no pagination | `basis: "population"` |
| **JapanDev** | `https://japan-dev.com/jobs` | 60 of the listed jobs; the board exposes no pagination endpoint | `basis: "sample"` |

Both counts are always reported separately, per source, as `totalListed` and `sampled`. **JapanDev's listed total is never counted as sampled** — the summary's `sampledJobs` only ever adds up what was actually read.

Each source's `basis` says what the returned statistics actually describe:

| `basis` | Meaning |
|---|---|
| `population` | every listed job on that board is in the statistics |
| `filtered_population` | the board served every listed job, but a `keyword` / `japaneseLevel` filter kept only part of them, so the statistics describe that subset — the summary's `basisFilter` carries the filter that produced it |
| `sample` | the board served only part of its listed jobs, so the statistics are a sample. A filtered sample stays a `sample` |

No login, no API key, no browser, nothing stored between runs. A run is 2 HTTP requests and takes a few seconds.

### Input

| Field | Example | Notes |
|---|---|---|
| `sources` | `["tokyodev", "japandev"]` | Which boards to aggregate. Default: both. Adding a board costs nothing extra |
| `keyword` | `"backend"` | Optional, case-insensitive, matched against job title + company. Empty = the whole English-speaker tech market |
| `japaneseLevel` | `"any"` | `any` / `none` / `conversational` / `business` / `fluent`. Filters the roles the statistics describe |
| `includeIndividualItems` | `false` | Enable to also get one record per matching role (+$0.002 each) |

### Output

One `type: "job_market_summary"` record per run:

```json
{
  "type": "job_market_summary",
  "keyword": null,
  "japaneseLevelFilter": "any",
  "sources": ["tokyodev", "japandev"],
  "perSource": [
    {"source": "tokyodev", "totalListed": 155, "sampled": 155, "basis": "population"},
    {"source": "japandev", "totalListed": 288, "sampled": 60,  "basis": "sample"}
  ],
  "basisFilter": null,
  "totalListed": 443,
  "sampledJobs": 215,
  "matchedJobs": 215,
  "salaryDisclosedJobs": 149,
  "salaryDisclosureRate": 0.693,
  "salaryMinMillionsJpy": {"min": 4.0, "p25": 7.0, "median": 8.5, "p75": 10.0, "max": 20.0, "average": 8.8},
  "salaryMaxMillionsJpy": {"min": 6.0, "p25": 12.0, "median": 14.0, "p75": 17.0, "max": 30.0, "average": 14.6},
  "salaryMidMillionsJpy": {"min": 5.0, "p25": 9.5, "median": 11.5, "p75": 13.5, "max": 25.0, "average": 11.7},
  "salaryRangeWidthMillionsJpy": {"min": 0.0, "p25": 4.0, "median": 5.5, "p75": 8.0, "max": 18.0, "average": 5.8},
  "japaneseRequirement": {"none": 114, "conversational": 21, "business": 71, "fluent": 9, "unknown": 0},
  "residency": {"japanResidentsOnly": 66, "canApplyFromAbroad": 129, "unknown": 20},
  "remote": {"Fully remote": 82, "Partial remote": 30, "unspecified": 103},
  "categoryTop": [{"category": "Software Engineering", "jobs": 61}],
  "companyCount": 132,
  "salaryByJapaneseLevel": [
    {"japaneseLevel": "none", "jobs": 114, "withSalary": 82,
     "medianMinMillionsJpy": 8.0, "medianMaxMillionsJpy": 14.0}
  ],
  "currency": "JPY",
  "salaryUnit": "millions_jpy_per_year",
  "checkedAt": "2026-07-27T09:00:00+00:00",
  "sourceUrls": ["https://www.tokyodev.com/jobs", "https://japan-dev.com/jobs"]
}
```

The `perSource`, `totalListed`, `sampledJobs` and disclosure counts are measured; the salary figures above show the record's **shape** — the actual distribution is whatever the boards publish on the day you run it.

With `includeIndividualItems: true` you additionally get one record per matching role:

```json
{
  "type": "job",
  "source": "tokyodev",
  "title": "Engineering Manager",
  "company": "SPIKE STUDIO",
  "salaryMinMillionsJpy": 8.0,
  "salaryMaxMillionsJpy": 16.0,
  "japaneseLevel": "business",
  "japaneseLevelBasis": "exact",
  "residency": "japan_residents_only",
  "remote": "Fully remote",
  "location": null,
  "category": "Engineering Management",
  "url": "https://www.tokyodev.com/companies/spike-studio"
}
```

### Pricing — from $0.02 per call, no subscription

| Event | Price | When |
|---|---|---|
| Market summary (`market-analyzed`, primary event) | **$0.02** | Once per run |
| Individual job record (`job-scraped`) | **$0.002** | Only if you enable **Include individual job records** |

A default run (both boards, summary only) costs **$0.02**. Individual records are **off by default**. **A run that returns no jobs — or whose filters match none — is never charged.**

### Notes & limits

- **Wantedly is deliberately not a source.** It is the largest English-friendly board in Japan, but it does **not publish salaries**, and folding a salary-less board into a salary distribution would silently deflate every statistic here
- **JapanDev is a sample, and says so.** Its page server-renders 60 of its listed jobs and the board offers no pagination endpoint, so `basis: "sample"` and its `totalListed` is reported next to — never added into — `sampled`
- **A filtered run is never labelled a population.** Set a `keyword` or a `japaneseLevel` and every statistic describes the matching roles only, so TokyoDev's `basis` comes down to `filtered_population` and `basisFilter` records the filter that produced it. Sample-vs-population labelling is treated as correctness here, not decoration
- **JapanDev's Japanese signal is coarser than TokyoDev's.** It publishes only "Japanese Required" vs. nothing, so its roles map onto `business` / `none` and every such record carries `japaneseLevelBasis: "coarse"`. TokyoDev's four-level labels are `"exact"`
- **Residency is asymmetric on purpose.** On TokyoDev, roles without the "Japan residents only" label were measured to be open to applications from abroad, so absence is a value. On JapanDev only the positive "Apply from Abroad" tag exists, so its absence stays `unknown` rather than being guessed
- `location` is only published by JapanDev; `category` is only published by TokyoDev. Both stay `null` on the other board rather than being invented
- TokyoDev's job URLs are not reliably extractable from the listing page, so `url` is nullable
- These are **advertised** bands, not offers or paid salaries, and they exclude bonuses, stock and allowances. Roles that publish no band are counted, never imputed
- If a board's page states a job count but no job can be parsed, the run **fails that source** instead of reporting zero — a layout change must not look like an empty market. If every source fails, the run fails
- Read-only, HTTP only (no browser), throttled at 1 request / 1.5 s, 256 MB, ~2 requests per run
- **No personal data.** Job posts carry employer names only; recruiter and applicant names are neither parsed nor emitted

***

### 日本語ガイド

**日本の英語話者・バイリンガル向け IT 求人の「給与レンジ相場」を、1コール1レコードで返す Actor です。**

- **概要**: 給与を公開している英語圏向け求人ボード2つ（TokyoDev / JapanDev）を1回の実行で集計し、募集中求人の **年収レンジ（¥百万円単位）の分布**（最小・p25・中央値・p75・最大・平均）を返します。売りは2つ — **`salaryDisclosureRate`（そもそも給与を公開している求人の割合）** と **`salaryRangeWidthMillionsJpy`（`¥8M ~ ¥16M` というレンジの幅＝交渉余地）**。日本の求人媒体は給与非公開が主流なので、「N件中何件が金額を出しているか」自体が価値のある指標です。
- **主な出力**: 求める日本語レベル別の内訳と **`salaryByJapaneseLevel`（日本語要件が上がると給与も上がるのか＝中央値の下限・上限）**、在住要件（日本在住者限定／海外から応募可／不明）、リモート区分、職種カテゴリ上位、企業数。
- **母集団とサンプルの区別**: TokyoDev は1リクエストで**掲載中の全件**が返るため `basis: "population"`。JapanDev は掲載件数のうち **60件のみが HTML に含まれ、ページング API が存在しない**ため `basis: "sample"` とし、`totalListed`（掲載総数）と `sampled`（実際に読めた件数）を**必ず分けて**報告します。**JapanDev の掲載総数を `sampledJobs` に足すことはありません。**
- **`basis` の値**: `population`（そのボードの掲載全件が統計に入っている）/ `filtered_population`（全件は取得できたが `keyword`・`japaneseLevel` で絞り込んだため、統計は**その部分集合**の説明。絞り込み条件はサマリーの `basisFilter` に入ります）/ `sample`（ボードが掲載の一部しか返さないためサンプル。絞り込んでも `sample` のまま）。
- **使い方**: `sources` で対象ボードを選び（既定は両方）、`keyword` で職種名・社名の部分一致フィルタ（任意）、`japaneseLevel` で日本語要件による絞り込み（`any` / `none` / `conversational` / `business` / `fluent`）。個別求人の明細が必要なときだけ `includeIndividualItems` を ON にします。
- **料金**: サマリー1件（イベント `market-analyzed`）**$0.02**、個別求人レコード（イベント `job-scraped`）は **$0.002/件**（既定 OFF なので既定実行は $0.02 固定）。**0件・フィルタ不一致の実行には課金されません。** サブスクリプション不要です。
- **注意**: Wantedly は**給与が公開されていない**ため意図的に対象外です（給与統計が壊れるため）。JapanDev の日本語要件は「Japanese Required の有無」しかないため `business` / `none` に丸め、該当レコードには `japaneseLevelBasis: "coarse"` を付けます。掲載件数が取れているのに求人が1件も解析できない場合は、0件として返さず**そのソースを失敗させます**（レイアウト変更を空の結果と誤認しないため）。掲載されている金額は「提示レンジ」であり、賞与・株式・各種手当は含みません。**個人情報は取得しません**（企業名のみ）。

***

### 中文说明

**一次调用即可获取日本「英语／双语 IT 职位」的薪资区间行情。**

- **概览**: 本 Actor 同时读取两个公开薪资的英文日本招聘网站（TokyoDev / JapanDev），返回在招职位的**年薪区间分布（单位：百万日元）**——最小值 / p25 / 中位数 / p75 / 最大值 / 平均值。核心卖点有两个：**`salaryDisclosureRate`（究竟有多少职位公开了薪资）** 与 **`salaryRangeWidthMillionsJpy`（`¥8M ~ ¥16M` 这一区间的宽度，即议薪空间）**。日本多数招聘网站根本不公开薪资，因此「N 个职位中有几个给出了金额」本身就是有价值的指标。
- **主要输出**: 按所需日语水平拆分的分布与 **`salaryByJapaneseLevel`（要求日语是否更高薪：各水平的下限中位数与上限中位数）**、居住要求（仅限日本居住者／可从海外申请／未知）、远程办公构成、职位类别 Top 10、公司数量。
- **总体与样本严格区分**: TokyoDev 单次请求即可返回**全部在招职位**，故标记为 `basis: "population"`；JapanDev 页面仅服务端渲染其中 60 条且**不提供任何分页接口**，故标记为 `basis: "sample"`，并将 `totalListed`（挂牌总数）与 `sampled`（实际读取数）**分开报告**。**JapanDev 的挂牌总数绝不会被计入 `sampledJobs`。**
- **`basis` 取值**: `population`（该站点在招职位全部纳入统计）/ `filtered_population`（虽已取得全部职位，但 `keyword`／`japaneseLevel` 只保留了其中一部分，因此统计描述的是**该子集**；产生它的筛选条件记录在汇总的 `basisFilter` 中）/ `sample`（站点本身只返回部分职位，故为样本；加了筛选仍然是 `sample`）。
- **用法**: 用 `sources` 选择数据源（默认两个都用）；`keyword` 为可选的职位名／公司名不区分大小写筛选；`japaneseLevel` 按日语要求筛选（`any` / `none` / `conversational` / `business` / `fluent`）；只有在需要逐条职位明细时才打开 `includeIndividualItems`。
- **价格**: 每次调用的汇总记录（事件 `market-analyzed`）**$0.02**，逐条职位记录（事件 `job-scraped`）**$0.002/条**（默认关闭，因此默认运行固定为 $0.02）。**没有结果、或筛选后无匹配的运行不会计费。** 无需订阅。
- **注意**: Wantedly **不公开薪资**，故有意不作为数据源（混入会破坏薪资统计）。JapanDev 只有「Japanese Required」有无之分，因此归并为 `business` / `none`，并在相应记录上标注 `japaneseLevelBasis: "coarse"`。若页面给出了职位总数却一条都解析不出，本 Actor 会**让该数据源失败**而非返回 0（避免把版面改动误判为「市场为空」）。所列金额为**招聘方公示区间**，不含奖金、股权与各类津贴。**不采集任何个人信息**（仅公司名称）。

# Actor input Schema

## `sources` (type: `array`):

Which English-language Japanese tech job boards to aggregate. TokyoDev server-renders every listed position, so it is reported as a population; JapanDev serves 60 of its listed jobs with no pagination, so it is reported as a sample (both counts are always shown separately). Adding a board costs nothing extra — the run is charged once per call.

## `keyword` (type: `string`):

Optional case-insensitive filter matched against the job title and the company name (e.g. 'backend', 'data', 'Rakuten'). Leave empty to get the whole English-speaker tech market. When set, every statistic describes only the matching roles.

## `japaneseLevel` (type: `string`):

Keep only roles that require this level of Japanese. 'any' (default) keeps everything and lets you read the split from japaneseRequirement and salaryByJapaneseLevel. Note: JapanDev only publishes 'Japanese Required' vs nothing, so its roles land on 'business' or 'none' and are flagged japaneseLevelBasis: 'coarse'.

## `includeIndividualItems` (type: `boolean`):

Off by default: a run costs a flat $0.02 for the market summary. Enable to also get one record per matching role (source, title, company, salary band, Japanese level, residency, remote, location, category, URL) at +$0.002 per record.

## Actor input object example

```json
{
  "sources": [
    "tokyodev",
    "japandev"
  ],
  "keyword": "backend",
  "japaneseLevel": "any",
  "includeIndividualItems": 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 = {
    "sources": [
        "tokyodev",
        "japandev"
    ],
    "keyword": "backend"
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/japan-tech-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 = {
    "sources": [
        "tokyodev",
        "japandev",
    ],
    "keyword": "backend",
}

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/japan-tech-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 '{
  "sources": [
    "tokyodev",
    "japandev"
  ],
  "keyword": "backend"
}' |
apify call jpmarketdata/japan-tech-jobs-market-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Japan Tech Jobs Market Checker — Bilingual IT Salary Stats",
        "description": "Salary stats for English-speaking / bilingual IT jobs in Japan (TokyoDev + JapanDev) in one call: advertised ¥M bands, how many roles disclose pay at all, band width, Japanese level, remote and residency mix. From $0.02. 日本のバイリンガルIT求人の給与レンジ統計を1コールで。一次调用获取日本双语IT职位薪资区间统计。",
        "version": "0.1",
        "x-build-id": "x4yjfPCRrza55O865"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jpmarketdata~japan-tech-jobs-market-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jpmarketdata-japan-tech-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-tech-jobs-market-checker/runs": {
            "post": {
                "operationId": "runs-sync-jpmarketdata-japan-tech-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-tech-jobs-market-checker/run-sync": {
            "post": {
                "operationId": "run-sync-jpmarketdata-japan-tech-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",
                "properties": {
                    "sources": {
                        "title": "Job boards",
                        "maxItems": 2,
                        "type": "array",
                        "description": "Which English-language Japanese tech job boards to aggregate. TokyoDev server-renders every listed position, so it is reported as a population; JapanDev serves 60 of its listed jobs with no pagination, so it is reported as a sample (both counts are always shown separately). Adding a board costs nothing extra — the run is charged once per call.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "tokyodev",
                                "japandev"
                            ],
                            "enumTitles": [
                                "TokyoDev (www.tokyodev.com)",
                                "JapanDev (japan-dev.com)"
                            ]
                        },
                        "default": [
                            "tokyodev",
                            "japandev"
                        ]
                    },
                    "keyword": {
                        "title": "Keyword filter (optional)",
                        "type": "string",
                        "description": "Optional case-insensitive filter matched against the job title and the company name (e.g. 'backend', 'data', 'Rakuten'). Leave empty to get the whole English-speaker tech market. When set, every statistic describes only the matching roles."
                    },
                    "japaneseLevel": {
                        "title": "Required Japanese level",
                        "enum": [
                            "any",
                            "none",
                            "conversational",
                            "business",
                            "fluent"
                        ],
                        "type": "string",
                        "description": "Keep only roles that require this level of Japanese. 'any' (default) keeps everything and lets you read the split from japaneseRequirement and salaryByJapaneseLevel. Note: JapanDev only publishes 'Japanese Required' vs nothing, so its roles land on 'business' or 'none' and are flagged japaneseLevelBasis: 'coarse'.",
                        "default": "any"
                    },
                    "includeIndividualItems": {
                        "title": "Include individual job records",
                        "type": "boolean",
                        "description": "Off by default: a run costs a flat $0.02 for the market summary. Enable to also get one record per matching role (source, title, company, salary band, Japanese level, residency, remote, location, category, URL) at +$0.002 per record.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```