# at home Japan Rent Market — Rent, Fee & Deposit Stats by Area (`jpmarketdata/athome-rent-market-checker`) Actor

Rent statistics for any Japanese area from at home (アットホーム), one of Japan's big three property portals: rent, management-fee and total-monthly quartiles, deposit/key-money practice, floor-plan mix and rent per m². From $0.02 per area, no subscription. アットホームの賃貸相場を1コールで。一次调用获取日本各区域的租金行情。

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

## Pricing

from $20.00 / 1,000 area 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

## at home Japan Rent Market — Rent, Fee & Deposit Stats by Area

**What does it actually cost to rent here?** One call per area answers it with the rent distribution of [at home](https://www.athome.co.jp/) (アットホーム — one of Japan's three big property portals, alongside SUUMO and HOME'S), plus the three numbers listing sites make you compute yourself: the **total monthly outlay**, the **move-in terms**, and the **price of a square metre**.

### Overview

One compact record per area:

- **`rentJpy`** — min / p25 / median / p75 / max / average of the rent (賃料), in yen
- **`managementFeeJpy`** and **`totalMonthlyJpy`** — the management fee (管理費・共益費) is quoted separately from rent on every Japanese portal, so the advertised rent is never what you pay. `totalMonthlyJpy` is rent + fee per room, then aggregated
- **`depositMonths` / `keyMoneyMonths`** — how the area handles 敷金 (deposit) and 礼金 (key money), binned as `none` / `one` / `two` / `other` months, plus **`noDepositNoKeyMoneyShare`**: the share of rooms asking for **neither** — the move-in cost renters actually shop on
- **`floorPlanTop`** — the top 10 floor plans (1K, 1LDK, 2LDK …) with counts
- **`floorAreaSqm`** and **`rentPerSqmJpy`** — the size distribution and the yen-per-square-metre distribution, the only figure that compares two areas honestly
- **`sampledRooms` / `sampledBuildings`** — one building carries several vacant rooms, and both are counted
- Optionally every sampled room as its own record

No login, no API key, no browser, nothing stored between runs.

### Input

| Field | Example | Notes |
|---|---|---|
| `areas` | `["tokyo"]` | The at home area path — the part between `/chintai/` and `/list/` in `https://www.athome.co.jp/chintai/<area>/list/`. A narrower path such as `tokyo/shibuya-city` works, and a full `https://www.athome.co.jp/chintai/.../list/` URL is accepted and normalised for you. **Up to 10 areas per run**, each a separate billable unit at **$0.02 per area** |
| `pagesPerArea` | `3` | List pages per area, 1–8. One page holds roughly **150 rooms** (~130 buildings), so the default samples ~450 rooms per area |
| `includeIndividualItems` | `false` | Off by default. Enable to also get every sampled room as a record, **+$0.002 per room** |

```json
{
  "areas": ["tokyo"],
  "pagesPerArea": 3,
  "includeIndividualItems": false
}
```

### Output

One `area_summary` per area (example **shape**; values are illustrative):

```json
{
  "type": "area_summary",
  "area": "tokyo",
  "areaUrl": "https://www.athome.co.jp/chintai/tokyo/list/",
  "totalListingsFound": null,
  "sampledRooms": 465,
  "sampledBuildings": 381,
  "pagesFetched": 3,
  "rentJpy": {"min": 45000, "p25": 82000, "median": 118000, "p75": 189000, "max": 980000, "average": 152300},
  "rentJpyP10P90": {"p10": 65000, "p90": 320000},
  "managementFeeJpy": {"min": 0, "p25": 0, "median": 5000, "p75": 10000, "max": 30000, "average": 6200},
  "managementFeeKnown": 441,
  "totalMonthlyJpy": {"min": 47000, "p25": 88000, "median": 124000, "p75": 197000, "max": 995000, "average": 158500},
  "totalMonthlyKnown": 441,
  "floorAreaSqm": {"min": 12.4, "p25": 25, "median": 40, "p75": 62, "max": 210.5, "average": 46},
  "floorAreaKnown": 402,
  "rentPerSqmJpy": {"min": 1980, "p25": 2870, "median": 3310, "p75": 3960, "max": 9800, "average": 3480},
  "rentPerSqmKnown": 402,
  "floorPlanTop": [["1K", 121], ["1LDK", 98], ["2LDK", 74], ["1DK", 41]],
  "depositMonths": {"none": 180, "one": 210, "two": 61, "other": 14},
  "keyMoneyMonths": {"none": 205, "one": 198, "two": 48, "other": 14},
  "roomsWithDepositAndKeyMoneyKnown": 465,
  "noDepositNoKeyMoneyRooms": 96,
  "noDepositNoKeyMoneyShare": 0.2065,
  "medianRoomsPerBuilding": 1,
  "samplingOrder": "site_default",
  "samplingOrderNote": "Rooms are sampled in at home's own default listing order across pagesPerArea pages; that order was not verified to be neutral.",
  "checkedAt": "2026-07-27T09:00:00+00:00",
  "sourceUrl": "https://www.athome.co.jp/chintai/tokyo/list/"
}
```

With `includeIndividualItems: true` you additionally get one record per room:

```json
{
  "type": "room",
  "area": "tokyo",
  "buildingIndex": 12,
  "roomNumber": "301 3階",
  "rentJpy": 160000,
  "managementFeeJpy": 0,
  "depositRaw": "なし",
  "keyMoneyRaw": "1ヶ月",
  "floorPlan": "1LDK",
  "floorAreaSqm": 48.23,
  "rentPerSqmJpy": 3317
}
```

`buildingIndex` groups the rooms that belong to the same building, so you can tell one vacant room in 40 buildings apart from 40 vacant rooms in one building (`medianRoomsPerBuilding` reports it directly).

**Every statistic states how many rooms it was computed on.** Not every listing publishes every field, so a statistic taken over the rooms that do publish it ships with its own denominator instead of borrowing `sampledRooms`:

| Statistic | Its denominator | Meaning |
|---|---|---|
| `rentJpy`, `rentJpyP10P90`, `floorPlanTop`, `depositMonths`, `keyMoneyMonths` | `sampledRooms` | every sampled room (a row with no readable rent is not a room) |
| `managementFeeJpy` | `managementFeeKnown` | rooms whose management fee could be read (「―」/「なし」 counts as a real ¥0) |
| `totalMonthlyJpy` | `totalMonthlyKnown` | rooms where **both** rent and fee are known |
| `floorAreaSqm` | `floorAreaKnown` | rooms that quote a floor area |
| `rentPerSqmJpy` | `rentPerSqmKnown` | rooms with both a rent and a floor area |
| `noDepositNoKeyMoneyShare` | `roomsWithDepositAndKeyMoneyKnown` | rooms where both 敷金 and 礼金 could be read |

So `rentPerSqmJpy.median` with `rentPerSqmKnown: 402` out of `sampledRooms: 465` is the median of those 402 rooms — never presented as if it covered all 465.

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

| Event | Price | When |
|---|---|---|
| Area market summary (`area-analyzed`, primary event) | **$0.02** | Once per area analyzed |
| Individual room record (`room-scraped`) | **$0.002** | Only if you enable **Include individual rooms** |

A default run (1 area, 3 pages, summary only) costs **$0.02**. Individual room records are **off by default**, so the price of a run is predictable: enabling them on a 3-page area adds roughly 450 × $0.002.

**An area that returns no room is never charged.**

### Notes & limits

- **`totalListingsFound` is always `null` — on purpose.** at home's list page is full of facet counts (per ward, per station line, per rent band), so no 「…件」 on the page can be trusted to be the total for your query. Publishing a facet count as the market size would be worse than publishing nothing, so this Actor reports what it actually read: `sampledRooms` and `sampledBuildings`
- **`samplingOrder: "site_default"`.** Rooms are sampled in at home's own default listing order. That order was **not verified to be neutral** (portals commonly weight promoted listings first), which is why sampling spreads across `pagesPerArea` pages instead of reading the first page only — and why the caveat travels inside every record instead of living in the docs
- **A management fee of `0` means the listing says 「―」 or 「なし」** (no fee), while `null` means the value could not be read. `totalMonthlyJpy` is only computed when both parts are known
- `floorAreaSqm` uses the same statistics helper as every other balloon Actor, which rounds the quartiles to whole numbers; `min` and `max` keep the site's own decimals
- Deposit / key money is binned rather than averaged: values are quoted in months, occasionally in yen, so `other` collects everything that is not 0, 1 or 2 months. `depositRaw` / `keyMoneyRaw` keep at home's own wording so nothing is hidden behind the bin
- Read-only and throttled (1 request / 1.5 s), HTTP only — no browser, 256 MB. A run has a 95-second soft budget, which guards both levels: an area that hits it mid-way returns what it has with `truncatedForTimeLimit: true` and a smaller `pagesFetched` instead of failing, and once the budget is spent no **new** area is started — the areas that were not started are named in the run log and are never charged. `areas` is capped at 10 per run for the same reason
- **Page 1 with zero room rows fails that area** rather than returning an empty summary — at home always returns listings for a valid area, so an empty first page means the area path is wrong, the layout changed, or the request was blocked. Other areas in the same run continue; a run where *every* area fails is a failed run
- **An empty page 2 or later simply ends that area**, keeping every room already collected: a small ward can hold fewer listings than `pagesPerArea` pages, and `pagesFetched` then reports the pages that actually carried rooms. Asking for 3 pages of a one-page ward is an ordinary input, not an error
- **No personal data.** Only property attributes are parsed and emitted — agent names, phone numbers and contact details are never read
- Rent asks, not signed leases: portal listings are advertised prices, and the same building can appear in several areas

### Use cases

- **Relocation & expat budgeting** — what a 1LDK really costs per month in this ward, deposit practice included
- **Investor / landlord pricing** — set an asking rent against the local ¥/m² median instead of gut feel
- **Cross-portal sanity check** — an independent second reading next to SUUMO for the same area
- **Time series** — schedule the Actor and track the median rent and the no-deposit share per area over time

***

### 日本語ガイド

**アットホーム（www.athome.co.jp）の賃貸相場を、エリア1件につき1レコードで返す Actor です。**

- **概要**: エリアごとに **賃料の分布（最小・p25・中央値・p75・最大・平均）** に加えて、**管理費の分布**と**月額総額（賃料＋管理費）**、**敷金・礼金の実態**（0ヶ月／1ヶ月／2ヶ月／その他の件数と、「敷金・礼金どちらも不要」の割合）、**間取り内訳（上位10）**、**専有面積の分布**、**㎡単価（円/m²）** を返します。建物1件に複数の空室がぶら下がるため、`sampledRooms`（部屋数）と `sampledBuildings`（建物数）を分けて報告します。
- **使い方**: `areas` には `https://www.athome.co.jp/chintai/<area>/list/` の `<area>` 部分（例 `tokyo`、`tokyo/shibuya-city`）を指定します。一覧URLをそのまま貼っても正規化されます。**エリアは1回の実行につき最大10件**（1件ずつ課金される単位です）。`pagesPerArea` は 1〜8（1ページ約150部屋）。個別の部屋レコードが必要なときだけ `includeIndividualItems` を ON にします。
- **料金**: エリアサマリー1件 **$0.02**（`area-analyzed`）、個別の部屋レコードは **$0.002/件**（`room-scraped`。既定 OFF なので既定実行は $0.02 固定）。**0件のエリアには課金されません。**
- **統計ごとの母数を明示**: 管理費・月額総額・専有面積・㎡単価は「その項目を掲載している部屋」だけで計算されるため、件数を `managementFeeKnown` / `totalMonthlyKnown` / `floorAreaKnown` / `rentPerSqmKnown` として併記します（敷金・礼金は従来どおり `roomsWithDepositAndKeyMoneyKnown`）。`sampledRooms` を母数と誤読する余地をなくすためです。
- **総件数は返しません（`totalListingsFound: null`）**: 一覧ページには絞り込み条件ごとの件数が大量に並ぶため、ページ上の「…件」を検索結果の総数として信用できません。**推測値を出すよりも null を返す**方針です。実際に読み取った `sampledRooms` / `sampledBuildings` をご利用ください。
- **並び順**: サイト既定の並び順でサンプリングします（`samplingOrder: "site_default"`）。**既定順が中立である保証は未確認**のため、複数ページに跨ってサンプリングし、その但し書きを全レコードに含めています。
- **その他**: 管理費の `0` は「―／なし」の明示、`null` は読み取り不可を意味します。掲載は募集価格であり成約価格ではありません。**担当者名・電話番号などの個人情報は一切取得・出力しません。** 1.5秒間隔のリクエスト、HTTPのみ（ブラウザ不使用）、95秒のソフト上限を超えた場合は `truncatedForTimeLimit: true` を付けて取得済みの分を返し、**未着手のエリアはログに明記したうえでスキップ**します（課金されません）。**1ページ目が0件のエリアはエラー**（パス誤り・レイアウト変更・ブロックの疑い）ですが、**2ページ目以降が0件の場合は物件が尽きただけ**なので、そこで打ち切って取得済みの分を返し `pagesFetched` に実際の取得ページ数を記録します。

***

### 中文说明

**本 Actor 从日本三大房产门户之一的 at home（アットホーム，www.athome.co.jp）抓取指定区域的租房行情，每个区域返回一条汇总记录。**

- **功能**: 返回该区域的 **租金分布**（最小值 / p25 / 中位数 / p75 / 最大值 / 平均值）、**管理费分布**、**每月实付总额**（租金＋管理费）、**押金（敷金）与礼金**的实际情况（0 / 1 / 2 个月及其他的套数，以及「押金礼金全免」的占比）、**户型排行（前10）**、**使用面积分布**与**每平方米租金**。一栋楼常有多间空房，因此房间数（`sampledRooms`）与楼栋数（`sampledBuildings`）分开统计。
- **用法**: `areas` 填写 `https://www.athome.co.jp/chintai/<area>/list/` 中的 `<area>`（如 `tokyo`、`tokyo/shibuya-city`），直接粘贴完整列表页链接也可以。**每次运行最多 10 个区域**（每个区域都是独立计费单位）。`pagesPerArea` 取值 1–8，每页约 150 间。需要逐间明细时再打开 `includeIndividualItems`。
- **价格**: 每个区域汇总 **$0.02**（`area-analyzed`），逐间房记录 **$0.002/条**（`room-scraped`，默认关闭，因此默认运行固定为 $0.02）。**无结果的区域不计费。**
- **每项统计都注明样本量**: 管理费、每月总额、使用面积与每平方米租金只在「有该项数据的房源」上计算，因此分别附带 `managementFeeKnown` / `totalMonthlyKnown` / `floorAreaKnown` / `rentPerSqmKnown`（押金礼金沿用 `roomsWithDepositAndKeyMoneyKnown`），避免被误读成覆盖全部 `sampledRooms`。
- **不返回总房源数（`totalListingsFound: null`）**: 列表页充斥着各类筛选项的计数，页面上的「…件」无法可靠地代表查询结果总数，因此本 Actor 宁可返回 null，也不给出猜测值，请以实际读取到的 `sampledRooms` / `sampledBuildings` 为准。
- **排序**: 采样使用网站默认排序（`samplingOrder: "site_default"`），**该排序是否中立尚未验证**，故跨多页采样以稀释首页偏差，并在每条记录中注明。
- **其他**: 管理费为 `0` 表示页面明确标注「―／なし」（无管理费），`null` 表示无法读取。数据为挂牌租金而非成交价。**不采集、不输出经纪人姓名与电话等个人信息。** 请求间隔 1.5 秒，仅用 HTTP（不启动浏览器），超过 95 秒软预算时会返回已获取的部分并标记 `truncatedForTimeLimit: true`，**尚未开始的区域会在日志中列出并跳过**（不计费）。**第 1 页为 0 条的区域判定为失败**（路径错误、页面改版或被拦截）；**第 2 页及以后为 0 条只说明房源已取完**，此时保留已抓取的内容并在 `pagesFetched` 中记录实际页数。

# Actor input Schema

## `areas` (type: `array`):

One or more at home area paths, i.e. the part between /chintai/ and /list/ in https://www.athome.co.jp/chintai/<area>/list/ — for example 'tokyo', 'osaka', 'kanagawa' or a narrower path such as 'tokyo/shibuya-city'. A full https://www.athome.co.jp/chintai/.../list/ URL is accepted too and is normalised for you. Each area is a separate billable unit and costs $0.02, and each one is fetched in turn — up to 10 areas per run, so a run always finishes inside its time limit. Split larger lists over several calls.

## `pagesPerArea` (type: `integer`):

How many list pages to sample per area. One page holds roughly 150 rooms (~130 buildings), so the default of 3 gives a ~450-room sample per area. More pages mean a wider sample and a longer run — pages are fetched 1.5 s apart, and a run stops adding pages once its 95-second budget is spent (the summary is then marked truncatedForTimeLimit).

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

Off by default: a run costs a flat $0.02 per area summary. Enable to also get every sampled room as its own record (room number, rent, management fee, deposit, key money, floor plan, floor area, rent per m²) at +$0.002 per room. With the default 3 pages that is roughly 450 rooms per area.

## Actor input object example

```json
{
  "areas": [
    "tokyo"
  ],
  "pagesPerArea": 3,
  "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 = {
    "areas": [
        "tokyo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/athome-rent-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 = { "areas": ["tokyo"] }

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/athome-rent-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 '{
  "areas": [
    "tokyo"
  ]
}' |
apify call jpmarketdata/athome-rent-market-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "at home Japan Rent Market — Rent, Fee & Deposit Stats by Area",
        "description": "Rent statistics for any Japanese area from at home (アットホーム), one of Japan's big three property portals: rent, management-fee and total-monthly quartiles, deposit/key-money practice, floor-plan mix and rent per m². From $0.02 per area, no subscription. アットホームの賃貸相場を1コールで。一次调用获取日本各区域的租金行情。",
        "version": "0.1",
        "x-build-id": "NoLVBgxJJyhRCgGS0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jpmarketdata~athome-rent-market-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jpmarketdata-athome-rent-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~athome-rent-market-checker/runs": {
            "post": {
                "operationId": "runs-sync-jpmarketdata-athome-rent-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~athome-rent-market-checker/run-sync": {
            "post": {
                "operationId": "run-sync-jpmarketdata-athome-rent-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": [
                    "areas"
                ],
                "properties": {
                    "areas": {
                        "title": "Areas",
                        "maxItems": 10,
                        "type": "array",
                        "description": "One or more at home area paths, i.e. the part between /chintai/ and /list/ in https://www.athome.co.jp/chintai/<area>/list/ — for example 'tokyo', 'osaka', 'kanagawa' or a narrower path such as 'tokyo/shibuya-city'. A full https://www.athome.co.jp/chintai/.../list/ URL is accepted too and is normalised for you. Each area is a separate billable unit and costs $0.02, and each one is fetched in turn — up to 10 areas per run, so a run always finishes inside its time limit. Split larger lists over several calls.",
                        "default": [
                            "tokyo"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "pagesPerArea": {
                        "title": "Pages per area",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "How many list pages to sample per area. One page holds roughly 150 rooms (~130 buildings), so the default of 3 gives a ~450-room sample per area. More pages mean a wider sample and a longer run — pages are fetched 1.5 s apart, and a run stops adding pages once its 95-second budget is spent (the summary is then marked truncatedForTimeLimit).",
                        "default": 3
                    },
                    "includeIndividualItems": {
                        "title": "Include individual rooms",
                        "type": "boolean",
                        "description": "Off by default: a run costs a flat $0.02 per area summary. Enable to also get every sampled room as its own record (room number, rent, management fee, deposit, key money, floor plan, floor area, rent per m²) at +$0.002 per room. With the default 3 pages that is roughly 450 rooms per area.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
