# Mansion Review Scraper — Japan Condo Valuation Data & API (`sian.agency/mansion-review-valuation-scraper`) Actor

Mansion-Review.jp scraper & data API for Japan condo resale valuations. One record per building: monthly 坪単価 (price-per-tsubo) resale series + city/town/station benchmarks, deviation score, rating, listed-price range, build year, floors, units, station access, photos. Clean JSON/CSV.

- **URL**: https://apify.com/sian.agency/mansion-review-valuation-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Real estate, Automation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 valuation extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Mansion Review Scraper — Japan Condo Valuation Data & API 🏯

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Store-SUUMO Scraper](https://img.shields.io/badge/Store-SUUMO%20Scraper-1AE392)](https://apify.com/sian.agency/suumo-property-scraper?fpr=sian) [![Store-LIFULL HOMES](https://img.shields.io/badge/Store-LIFULL%20HOME'S-1AE392)](https://apify.com/sian.agency/lifull-homes-property-scraper?fpr=sian) [![Store-Immobiliare](https://img.shields.io/badge/Store-Immobiliare-E60023)](https://apify.com/sian.agency/immobiliare-property-scraper?fpr=sian)

#### 🎉 The only scraper for Japan's condo resale-VALUATION database — a full monthly price-per-tsubo (坪単価) history for every building, not just live listings
##### Built for analysts, investors and proptech teams who need real condo price trends, not for-sale ads

---

### 📋 Overview

**Most Japan real-estate scrapers give you today's for-sale ads.** This one gives you the *valuation* — one clean record per **building** with its complete monthly resale price-per-tsubo (坪単価) history, the deviation score (偏差値), user rating, current listed-price range, and city/town/station benchmark series to compare against. It's the difference between a snapshot and a trend line.

**Why analysts and investors choose this actor:**
- ✅ **One record per building, not per ad**: A deduplicated, building-level dataset — the right shape for valuation and trend work.
- 📈 **Full resale price history**: Monthly 坪単価 series going back ~15 years (200+ points per building), plus month-over-month and year-over-year change pre-computed.
- 🎯 **Built-in benchmarks**: City, town and per-station 坪単価 benchmark series ship in the same record — compare any building to its market instantly.
- 💴 **Analyst-ready KPIs**: Latest 坪単価 converted to ¥/m², deviation score, rating, listed-price range, build year, floors and total units — no post-processing.
- 💰 **Pay only per building**: Transparent pay-per-result pricing. No charge until your input is validated.
- ✨ **Two ways to target**: Sweep a whole area (prefecture / city / town / station / line) or pull specific buildings by URL or ID.

### ✨ Features

- 🏯 **Building-level valuations**: One row per condo building with its 坪単価 resale series and meta.
- 📈 **Monthly price series**: Up to ~15 years of monthly resale price-per-tsubo points per building.
- 📊 **Pre-computed momentum**: Month-over-month and year-over-year % change calculated for you.
- 🧭 **Market benchmarks**: City, town and per-station benchmark series in every record.
- 🔑 **Optional rent series**: Add each building's chintai (rent) 坪単価 series for yield analysis.
- 📍 **Area sweep or pinpoint**: Discover every building in an area, or value exact buildings by URL/ID.
- 💴 **Currency-correct**: All prices in JPY, 坪単価 kept in the native ¥10k/tsubo unit and converted to ¥/m².
- 🗂️ **Clean exports**: JSON, CSV and Excel straight from the Apify dataset — feed a dashboard or an API.

### 🎬 Quick Start

Paste an area URL (or a few building IDs), set how many buildings you want, and run. You get a structured dataset with one valuation record per building.

```bash
curl -X POST https://api.apify.com/v2/acts/sian.agency~mansion-review-valuation-scraper/runs?token=YOUR_TOKEN \
-H 'Content-Type: application/json' \
-d '{"searchMode":"byArea","areaUrls":["https://www.mansion-review.jp/mansion/city/667.html"],"maxResults":25}'
````

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose how to target

Pick **By area** to sweep a prefecture / city / town / station page, or **By building** to value specific buildings by URL or ID.

#### Step 2: Paste your targets

Drop in one or more area URLs (or building URLs/IDs), and set the max number of buildings and the price-series window.

#### Step 3: Run and export

Start the run. Download your valuation dataset as JSON, CSV or Excel — or pull it via the API.

**That's it! In a couple of minutes, you'll have:**

- A deduplicated, building-level valuation dataset
- A full monthly 坪単価 resale history per building
- City / town / station benchmarks to compare against

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| searchMode | string | No | `byArea` (sweep an index/hub page) or `byBuildingId` (specific buildings). Default `byArea`. |
| areaUrls | array | No | mansion-review.jp index/hub URLs (prefecture/city/town/station). Used in `byArea` mode. |
| areaKind | string | No | Area kind (`prefecture`/`city`/`town`/`station`/`line`/`ranking`) — alternative to a URL. |
| areaId | string | No | Numeric ID for the chosen area kind (e.g. `667`). |
| buildingIds | array | No | Building URLs or numeric IDs. Used in `byBuildingId` mode. |
| maxResults | integer | No | Max buildings per run (FREE: 25, PAID: unlimited). Default 100. |
| yearsAgo | integer | No | Years of monthly price history to pull. Default 10. |
| includeRentSouba | boolean | No | Also fetch each building's rent (chintai) 坪単価 series. Default false. |

**Example — sweep a city:**

```json
{
  "searchMode": "byArea",
  "areaUrls": ["https://www.mansion-review.jp/mansion/city/667.html"],
  "maxResults": 50
}
```

**Example — value specific buildings with rent series:**

```json
{
  "searchMode": "byBuildingId",
  "buildingIds": ["763410", "1434087"],
  "includeRentSouba": true
}
```

### 📤 Output

Results are saved to the Apify dataset with **40+ fields** including:

| Field | Type | Description |
|-------|------|-------------|
| id | string | Building identifier |
| name | string | Condo / building name |
| latest\_tsubo\_tanka | number | Most recent monthly resale price per tsubo (¥10k/tsubo) |
| latest\_price\_per\_sqm\_jpy | integer | Latest price per m² (¥) |
| mom\_change\_pct | number | Month-over-month % change |
| yoy\_change\_pct | number | Year-over-year % change |
| deviation\_score | integer | Condo deviation score (偏差値) |
| rating\_value | number | Aggregate user rating |
| listed\_low\_price / listed\_high\_price | integer | Current listed-price range (¥) |
| tsubo\_tanka\_series | object | Full monthly resale series keyed by YYYYMM |
| city\_tsubo\_tanka\_series | object | City-level benchmark series |
| built\_year / total\_units / floors\_above | integer | Building attributes |
| nearest\_station / station\_access | string | Station name and access text |

**Example:**

```json
{
  "id": "763410",
  "name": "パークシティ武蔵小山ザタワー",
  "latest_month": "202605",
  "latest_tsubo_tanka": 1073.74,
  "latest_price_per_sqm_jpy": 3248064,
  "mom_change_pct": 0.3,
  "yoy_change_pct": 37.2,
  "deviation_score": 79,
  "rating_value": 5.0,
  "listed_low_price": 57000000,
  "listed_high_price": 348000000,
  "currency": "JPY",
  "built_year": 2021,
  "total_units": 439,
  "prefecture": "東京都",
  "city": "品川区",
  "nearest_station": "武蔵小山駅",
  "series_points": 209
}
```

### 💼 Use Cases & Examples

#### 1. Condo resale-price comparables

**Appraisers and agents pricing a unit against its building's own history.**

**Input:** A building URL or ID
**Output:** The full monthly 坪単価 resale series + current listed range
**Use:** Anchor a valuation to a real, building-specific price trend.

#### 2. Investment & yield analysis

**Investors screening buildings for momentum and rental yield.**

**Input:** A city or station area URL with `includeRentSouba`
**Output:** Resale series + rent series + build year and units per building
**Use:** Rank buildings by appreciation and gross yield in one pass.

#### 3. Market trend dashboards

**Proptech teams powering price-trend charts and heatmaps.**

**Input:** A prefecture or city sweep
**Output:** Building, city, town and station benchmark series
**Use:** Plot building vs market trend lines with no extra requests.

#### 4. Valuation & forecasting models

**Quants feeding a price model with clean monthly history.**

**Input:** A bulk list of building IDs
**Output:** 200+ monthly points per building with MoM/YoY pre-computed
**Use:** Train and backtest condo price forecasts.

#### 5. Building price-history reports

**Researchers documenting how a specific tower's value has moved.**

**Input:** A single building ID
**Output:** Its complete resale history, score, rating and attributes
**Use:** Produce a one-building price-history report instantly.

#### 6. Feeding a Japan real-estate data API

**Developers building a condo-valuation product.**

**Input:** Scheduled area sweeps
**Output:** A deduplicated building dataset refreshed on a cadence
**Use:** Back a valuation API or internal data warehouse.

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/mansion-review-valuation-scraper').call({
  searchMode: 'byArea',
  areaUrls: ['https://www.mansion-review.jp/mansion/city/667.html'],
  maxResults: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/mansion-review-valuation-scraper').call(
    run_input={
        'searchMode': 'byBuildingId',
        'buildingIds': ['763410', '1434087'],
        'includeRentSouba': True,
    }
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~mansion-review-valuation-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"searchMode":"byArea","areaUrls":["https://www.mansion-review.jp/mansion/city/667.html"]}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule (e.g. monthly) or webhook
2. **HTTP Request**: Call the actor API
3. **Process**: Handle the JSON valuation records
4. **Action**: Save to a warehouse, refresh a dashboard, or alert on price moves

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **25 buildings** per run — full feature access, same data quality
- No credit card required
- Perfect for testing and small studies

#### PAID Tier (Production Ready)

- **Unlimited** buildings per run
- Pay-per-result: only charged per building valued
- Optional rent-series enrichment billed separately, only when a rent series exists

💰 **Transparent pay-per-result** — you pay for the building records you keep, nothing more.

🔗 [View current pricing](https://apify.com/sian.agency/mansion-review-valuation-scraper?fpr=sian)

### ❓ Frequently Asked Questions

**Q: Is this for-sale listings or valuations?**
A: Valuations. You get one record per building with its full monthly resale price-per-tsubo (坪単価) history — not individual for-sale ads.

**Q: How far back does the price history go?**
A: Up to ~15 years of monthly points (often 200+ per building). Tune the window with `yearsAgo`.

**Q: How many buildings can I value?**
A: FREE tier: 25 per run. PAID tier: unlimited.

**Q: What is 坪単価 (tsubo-tanka)?**
A: The price per *tsubo* (≈3.306 m²), the standard Japanese unit. We keep the native ¥10k/tsubo value and also give you the ¥/m² conversion.

**Q: Can I get rental data too?**
A: Yes — enable `includeRentSouba` to add each building's chintai (rent) 坪単価 series.

**Q: What output formats are available?**
A: JSON, CSV and Excel — export directly from the Apify dataset.

### 🐛 Troubleshooting

- **No buildings found in `byArea`** — make sure the URL is an *index/area* page (prefecture/city/town/station) or the `/mansion/` hub, not a single building page.
- **A building has a short series** — newer buildings simply have fewer months of resale history; the series reflects what exists.
- **Rent fields are empty** — that building has no chintai (rent) series, or `includeRentSouba` was off.

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what has been chosen to be shared publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### 🤝 Support

Questions, feature requests or issues? Reach out via the Apify Console or leave a review — we read every one and ship improvements fast.

⭐ **Love this actor?** Leave a [5-star review](https://apify.com/sian.agency/mansion-review-valuation-scraper/reviews) — it helps other analysts discover it.

***

> **Disclaimer:** This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Mansion Review (mansion-review.jp) or any of its operators. "Mansion Review", 坪単価 series and all related names and trademarks are the property of their respective owners. Use this actor in compliance with the target site's terms of service and all applicable laws.

🔥 More automation tools: https://apify.com/sian.agency?fpr=sian

# Actor input Schema

## `searchMode` (type: `string`):

🧭 How to tell the scraper which buildings to value:

- **By area** — paste a prefecture / city / town / station index URL (or pick a kind + ID below). Every building listed on the index page is auto-discovered and valued. Leave the area inputs blank to scan the `/mansion/` hub.
- **By building** — paste specific building URLs or numeric IDs to value exactly those buildings.

## `areaUrls` (type: `array`):

📍 mansion-review.jp **index** URLs — a prefecture / city / town / station page or the `/mansion/` hub. Every building anchored on the page is discovered and valued. Used when **Target by = By area**.

**TIP:** Open any area page on mansion-review.jp (e.g. a city or station page), then copy the URL from the address bar.

**BULK EDIT:** Click "Bulk edit" to paste many URLs, one per line. Leave blank to scan the `/mansion/` hub.

## `areaKind` (type: `string`):

🗂️ Instead of a URL, pick an area **kind** and supply its **ID** below. Builds the index URL `https://www.mansion-review.jp/mansion/<kind>/<id>.html`.

## `areaId` (type: `string`):

🔢 The numeric ID for the chosen **Area kind** (e.g. `667` for a city). Found in any mansion-review.jp area URL. Required only when **Area kind** is set.

## `buildingIds` (type: `array`):

🆔 **By building mode.** mansion-review.jp building URLs (e.g. https://www.mansion-review.jp/mansion/763410.html) or bare numeric IDs (e.g. `763410`).

**BULK EDIT:** Click "Bulk edit" to paste many URLs/IDs, one per line.

## `maxResults` (type: `integer`):

🔢 Maximum buildings to value this run.

- **FREE tier:** capped at 25 buildings per run.
- **PAID tier:** unlimited — set as high as you need.

## `yearsAgo` (type: `integer`):

📅 How many years of monthly 坪単価 (resale price-per-tsubo) history to pull for each building. Default 10.

## `includeRentSouba` (type: `boolean`):

🔑 Also fetch each building's **chintai (rent) 坪単価** series alongside the resale series. One extra request per building; billed as a separate enrich event only for buildings that have a rent series.

## Actor input object example

```json
{
  "searchMode": "byArea",
  "areaUrls": [
    "https://www.mansion-review.jp/mansion/city/667.html",
    "https://www.mansion-review.jp/mansion/station/2600203.html"
  ],
  "areaKind": "",
  "areaId": "667",
  "buildingIds": [
    "763410",
    "https://www.mansion-review.jp/mansion/1434087.html"
  ],
  "maxResults": 100,
  "yearsAgo": 10,
  "includeRentSouba": false
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped mansion-review.jp building valuations (JSON/CSV/Excel).

# 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 = {
    "areaUrls": [
        "https://www.mansion-review.jp/mansion/city/667.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/mansion-review-valuation-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "areaUrls": ["https://www.mansion-review.jp/mansion/city/667.html"] }

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/mansion-review-valuation-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "areaUrls": [
    "https://www.mansion-review.jp/mansion/city/667.html"
  ]
}' |
apify call sian.agency/mansion-review-valuation-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sian.agency/mansion-review-valuation-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Mansion Review Scraper — Japan Condo Valuation Data & API",
        "description": "Mansion-Review.jp scraper & data API for Japan condo resale valuations. One record per building: monthly 坪単価 (price-per-tsubo) resale series + city/town/station benchmarks, deviation score, rating, listed-price range, build year, floors, units, station access, photos. Clean JSON/CSV.",
        "version": "1.0",
        "x-build-id": "tVWhFb5XHpruOtXfv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~mansion-review-valuation-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-mansion-review-valuation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/sian.agency~mansion-review-valuation-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-mansion-review-valuation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/sian.agency~mansion-review-valuation-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-mansion-review-valuation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchMode": {
                        "title": "🧭 Target by",
                        "enum": [
                            "byArea",
                            "byBuildingId"
                        ],
                        "type": "string",
                        "description": "🧭 How to tell the scraper which buildings to value:\n\n- **By area** — paste a prefecture / city / town / station index URL (or pick a kind + ID below). Every building listed on the index page is auto-discovered and valued. Leave the area inputs blank to scan the `/mansion/` hub.\n- **By building** — paste specific building URLs or numeric IDs to value exactly those buildings.",
                        "default": "byArea"
                    },
                    "areaUrls": {
                        "title": "📍 Area index / hub URLs",
                        "type": "array",
                        "description": "📍 mansion-review.jp **index** URLs — a prefecture / city / town / station page or the `/mansion/` hub. Every building anchored on the page is discovered and valued. Used when **Target by = By area**.\n\n**TIP:** Open any area page on mansion-review.jp (e.g. a city or station page), then copy the URL from the address bar.\n\n**BULK EDIT:** Click \"Bulk edit\" to paste many URLs, one per line. Leave blank to scan the `/mansion/` hub.",
                        "default": [
                            "https://www.mansion-review.jp/mansion/city/667.html"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "areaKind": {
                        "title": "🗂️ Area kind (optional)",
                        "enum": [
                            "",
                            "prefecture",
                            "city",
                            "town",
                            "station",
                            "line",
                            "ranking"
                        ],
                        "type": "string",
                        "description": "🗂️ Instead of a URL, pick an area **kind** and supply its **ID** below. Builds the index URL `https://www.mansion-review.jp/mansion/<kind>/<id>.html`.",
                        "default": ""
                    },
                    "areaId": {
                        "title": "🔢 Area ID (optional)",
                        "type": "string",
                        "description": "🔢 The numeric ID for the chosen **Area kind** (e.g. `667` for a city). Found in any mansion-review.jp area URL. Required only when **Area kind** is set."
                    },
                    "buildingIds": {
                        "title": "🆔 Building URLs or IDs",
                        "type": "array",
                        "description": "🆔 **By building mode.** mansion-review.jp building URLs (e.g. https://www.mansion-review.jp/mansion/763410.html) or bare numeric IDs (e.g. `763410`).\n\n**BULK EDIT:** Click \"Bulk edit\" to paste many URLs/IDs, one per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "🔢 Max buildings",
                        "minimum": 1,
                        "type": "integer",
                        "description": "🔢 Maximum buildings to value this run.\n\n- **FREE tier:** capped at 25 buildings per run.\n- **PAID tier:** unlimited — set as high as you need.",
                        "default": 100
                    },
                    "yearsAgo": {
                        "title": "📅 Price-series window (years)",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "📅 How many years of monthly 坪単価 (resale price-per-tsubo) history to pull for each building. Default 10.",
                        "default": 10
                    },
                    "includeRentSouba": {
                        "title": "🔑 Add rent price series (enrich)",
                        "type": "boolean",
                        "description": "🔑 Also fetch each building's **chintai (rent) 坪単価** series alongside the resale series. One extra request per building; billed as a separate enrich event only for buildings that have a rent series.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```