# nomu Scraper — Japan Real Estate Data & API (`sian.agency/nomu-property-scraper`) Actor

nomu (ノムコム) scraper & real estate data API for Nomura's Japanese property portal. Used-condo (中古マンション) sale listings: price, layout, area, floor, building age, station access, management & repair fees, transaction terms, photos — clean JSON/CSV. Fast overview or full detail. No nomu account needed.

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

## Pricing

from $3.00 / 1,000 overview listing 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

## nomu Scraper — Japan Real Estate 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 Immobiliare Scraper](https://img.shields.io/badge/Store-Immobiliare%20Scraper-E60023)](https://apify.com/sian.agency/immobiliare-property-scraper?fpr=sian) [![Store Trip.com Scraper](https://img.shields.io/badge/Store-Trip.com%20Scraper-2577E3)](https://apify.com/sian.agency/trip-com-scraper?fpr=sian)

#### 🎉 Turn nomu.com listings into a clean, structured dataset — price, layout, area, fees, station access & photos in seconds
##### Built for property investors, analysts, agents & researchers tracking Japan's used-condo market

---

### 📋 Overview

**Pull live Japanese real-estate listings from nomu.com (ノムコム) into one tidy spreadsheet or JSON feed** — no account, no API key, no manual copy-pasting. nomu is Nomura's nationwide property portal, and this scraper turns its used-condo (中古マンション) sale listings into analysis-ready data.

**Why professionals choose this scraper:**
- ✅ **Complete listing data**: building name, price (clean JPY), layout, floor area, floor, building age, station access, management & repair fees, transaction terms and the full photo set
- ⚡ **Fast overview mode**: the search cards already carry ~90% of the useful fields — paginate a whole ward in seconds
- 🎯 **Price normalisation built in**: Japanese 億/万円 prices parsed to integer yen, plus an automatic **price-per-m²** column for instant comparison
- 💴 **Pay only for results**: transparent pay-per-listing pricing, generous free tier, no charge until your input is validated
- 💎 **Two depths, one record**: cheap overview for breadth, optional detail enrichment for the full spec table — merged into a single clean row
- ✨ **Search any way you like**: by area code, by a pasted nomu search URL (your filters preserved), or by specific listing URLs

---

### ✨ Features

- 🧭 **Overview mode** — fast, cheap listing cards across any ward or prefecture
- 🔎 **Detail mode** — enriches each listing with fees, transaction terms, current status, construction, land rights, balcony area and every photo
- 📍 **Search by area code** — target a specific ward (e.g. Chiyoda, Minato, Shibuya) or a whole prefecture
- 🔗 **Search by URL** — paste a nomu search page and every supported filter is preserved
- 🏠 **Fetch specific listings** — drop in listing URLs or bukken numbers for targeted pulls
- 💴 **Clean JPY prices** — 億/万円 expanded to integer yen, with a computed price-per-m²
- 📷 **Full photo galleries** — every listing image, de-duplicated
- 📤 **Export anywhere** — JSON, CSV, or Excel straight from the Apify dataset
- 🔢 **Tier-aware limits** — try it free, scale to unlimited when you're ready

---

### 🎬 Quick Start

Pick a mode, give it an area code or URL, and run. Results land in a clean dataset you can export as JSON, CSV, or Excel. The default input runs out of the box.

```bash
curl -X POST https://api.apify.com/v2/acts/sian.agency~nomu-property-scraper/runs?token=YOUR_TOKEN \
-H 'Content-Type: application/json' \
-d '{"scrapeMode":"overview","searchMode":"byPlace","places":["13101"],"pref":"tokyo","maxResults":50}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose your search

Pick **byPlace** (an area code like `13101` for Chiyoda-ku), **bySearchUrl** (paste a nomu search page), or **byListingUrl** (specific listings).

#### Step 2: Pick your depth

Use **overview** for fast, broad listing data, or **detail** to enrich each listing with the full spec table.

#### Step 3: Run & export

Click Start, then download your results as JSON, CSV, or Excel.

**That's it! In under a minute, you'll have:**

- A structured table of nomu listings
- Clean yen prices and price-per-m²
- Full building specs, fees and photo galleries

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| scrapeMode | string | No | `overview` (fast cards) or `detail` (full spec table) |
| searchMode | string | No | `byPlace`, `bySearchUrl`, or `byListingUrl` |
| propertyType | string | No | `mansion` (used condo), `house`, or `land` |
| places | array | No | nomu area codes, e.g. `["13101"]` (Chiyoda-ku) |
| pref | string | No | Prefecture slug, e.g. `tokyo`, `kanagawa`, `osaka` |
| searchUrls | array | No | Paste nomu search-results URLs |
| listingUrls | array | No | Specific listing URLs or bukken numbers (detail) |
| sort | string | No | `newest`, `price_asc`, `price_desc`, `area_desc`, … |
| filters | array | No | Extra `key=value` filters (price, area, layout, walk-time) |
| maxResults | integer | No | Listings per run (FREE: 25 · PAID: unlimited) |

**Example — scrape a ward:**

```json
{
  "scrapeMode": "overview",
  "searchMode": "byPlace",
  "places": ["13101"],
  "pref": "tokyo",
  "maxResults": 50
}
```

**Example — enrich specific listings:**

```json
{
  "scrapeMode": "detail",
  "searchMode": "byListingUrl",
  "listingUrls": ["https://www.nomu.com/mansion/id/FD1C5001/"]
}
```

***

### 📤 Output

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

| Field | Type | Description |
|-------|------|-------------|
| propertyTitle | string | Building name |
| price | number | Sale price in clean JPY |
| price\_per\_sqm\_jpy | number | Computed price per square metre |
| layout | string | Layout, e.g. 1LDK, 2LDK |
| area\_m2 | number | Exclusive floor area (m²) |
| floor | string | Unit floor |
| build\_date | string | Year/month built |
| transport | string | Rail line, station & walk time |
| location | string | Area / ward |
| management\_fee | string | Monthly management fee (detail) |
| repair\_reserve | string | Monthly repair reserve (detail) |
| transaction\_type | string | Brokerage / transaction terms (detail) |
| images | array | All photo URLs |

**Example:**

```json
{
  "listingId": "FD1C5001",
  "url": "https://www.nomu.com/mansion/id/FD1C5001/",
  "propertyTitle": "アルビオ・ザ・タワー千代田飯田橋",
  "price": 145000000,
  "price_formatted": "1億4,500万円",
  "currency": "JPY",
  "price_per_sqm_jpy": 3284258,
  "layout": "1LDK＋WIC＋SIC",
  "area_m2": 44.15,
  "floor": "3階",
  "build_date": "2021年1月",
  "transport": "中央・総武線「飯田橋」駅 徒歩3分",
  "management_fee": "19,820円 / 月",
  "transaction_type": "仲介",
  "image_count": 38
}
```

***

### 💼 Use Cases & Examples

#### 1. Property Investment Analysis

**Investors comparing yields across Tokyo wards.**

**Input:** Several area codes in overview mode
**Output:** Price, area, price-per-m² and building age for every listing
**Use:** Rank wards and buildings by value and spot underpriced units fast.

#### 2. Price & Market Research

**Analysts tracking the Japanese used-condo market.**

**Input:** A nomu search URL with your filters applied
**Output:** A clean time-stamped snapshot of the current market
**Use:** Build price trends and inventory dashboards over time.

#### 3. Real-Estate Lead Generation

**Agents and brokers sourcing inventory.**

**Input:** Target wards in detail mode
**Output:** Full listing specs including transaction terms and management company
**Use:** Identify and qualify listings to pitch buyers and sellers.

#### 4. Relocation & Home Search

**Buyers planning a move to Japan.**

**Input:** An area code plus filters for layout, area and walk-time
**Output:** Matching listings with station access and photos
**Use:** Shortlist homes without scrolling endless pages.

#### 5. Data Enrichment & Modelling

**Data teams building property datasets.**

**Input:** Listing URLs in detail mode
**Output:** Structured records with fees, construction and land rights
**Use:** Feed valuation models and internal databases.

***

### 🔗 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/nomu-property-scraper').call({
  scrapeMode: 'overview',
  searchMode: 'byPlace',
  places: ['13101'],
  pref: 'tokyo',
  maxResults: 50,
});

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/nomu-property-scraper').call(
    run_input={
        'scrapeMode': 'overview',
        'searchMode': 'byPlace',
        'places': ['13101'],
        'pref': 'tokyo',
        'maxResults': 50,
    }
)

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

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~nomu-property-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"scrapeMode":"overview","searchMode":"byPlace","places":["13101"],"pref":"tokyo"}'
```

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

1. **Trigger**: Schedule or webhook
2. **HTTP Request**: Call the actor API
3. **Process**: Handle the JSON results
4. **Action**: Save to a sheet, database, or alert

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

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

#### PAID Tier (Production Ready)

- **Unlimited** listings per run
- Pay-per-result: only charged for successful listings
- Optional detail enrichment for the full spec table

💴 **Pay only for what you extract** — the high-volume overview event is priced to be one of the most cost-effective ways to pull Japanese property data at scale.

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

***

### ❓ Frequently Asked Questions

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

**Q: Do I need a nomu account or API key?**
A: No — the scraper works without any login or key.

**Q: What's the difference between overview and detail?**
A: Overview is the fast, cheap path with ~90% of the fields. Detail fetches each listing's full page for fees, transaction terms, construction and the complete photo set.

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

**Q: Are prices normalised?**
A: Yes — Japanese 億/万円 prices are parsed to integer yen, and a price-per-m² column is added automatically.

**Q: Can I use my own nomu search filters?**
A: Yes — apply them on nomu and paste the search URL; every supported filter is preserved.

**Q: Is this legal?**
A: It extracts only publicly available listing data. See the legal note below.

***

### 🐛 Troubleshooting

**No results returned**

- Check the area code and prefecture slug match (e.g. `13101` with `tokyo`)
- If you pasted a search URL, confirm it's a nomu.com search-results page

**Fewer results than expected**

- FREE tier caps each run at 25 listings — upgrade for unlimited
- Some premium listings use a different page layout and are skipped in detail mode

**A specific listing is missing in detail mode**

- A small fraction of premium listings are served on a JavaScript microsite without a server-side spec table and are skipped cleanly

***

### ⚖️ 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/).

#### Trademark notice

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by** nomu.com, Nomura Real Estate Urban Net Co., Ltd., or any of their group companies. "nomu" and "ノムコム" are trademarks of their respective owners and are used here for descriptive and identification purposes only.

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, reach out via the channels below
- Check [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `scrapeMode` (type: `string`):

🧭 **OVERVIEW** (cheap, primary): listing cards from the search results — price, layout, area, floor, building age, location, station access, highlight & thumbnails. The cards already carry ~90% of the useful fields.

🔎 **DETAIL** (enrich): fetches each listing's full page for the spec table — management/repair fees, transaction terms, current status, construction, land rights, balcony area and the full photo set. Detail merges overview + detail into one record.

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

🔀 How listings are discovered.

- **byPlace** — give one or more nomu JIS area codes (e.g. `13101` for Chiyoda-ku, Tokyo) + a prefecture slug.
- **bySearchUrl** — paste a ready-made nomu search URL with your filters applied in the UI (most reliable).
- **byListingUrl** — fetch specific listings directly (DETAIL only).

## `propertyType` (type: `string`):

🏘️ Which nomu vertical to scrape.

- **mansion** (中古マンション) — used condos for sale; fully supported and the default.
- **house** (中古一戸建て) — used houses for sale.
- **land** (土地) — land for sale.

## `places` (type: `array`):

📍 **BY AREA CODE:** nomu JIS area codes to scrape (5-digit ward / city codes). Common codes: `13101` Chiyoda-ku, `13103` Minato-ku, `13104` Shinjuku-ku, `13113` Shibuya-ku. A 2-digit prefecture code (e.g. `14` Kanagawa) widens the search to the whole prefecture.

💡 **TIP:** For precise filtering, use **bySearchUrl** instead — apply your filters in nomu's UI and paste the URL.

## `pref` (type: `string`):

🗾 nomu prefecture slug used with the area code path (`area_<pref>/<code>`). `tokyo` is the default; others include `kanagawa`, `osaka`, `aichi`, `fukuoka`, `hokkaido`.

## `searchUrls` (type: `array`):

🔗 **BY SEARCH URL:** Paste one or more nomu search-results URLs (the `/mansion/area_tokyo/13101/` pages). Apply all your filters in the nomu UI first, then copy the address — every supported filter is preserved.

## `listingUrls` (type: `array`):

🏠 **BY LISTING URL (DETAIL ONLY):** Paste nomu detail URLs (e.g. `https://www.nomu.com/mansion/id/FD1C5001/`) or bare bukken numbers. Used with scrapeMode = detail.

## `sort` (type: `string`):

↕️ **OPTIONAL:** Sort the byPlace search results.

## `filters` (type: `array`):

🎛️ **OPTIONAL:** Extra nomu query filters as `key=value`, applied to byPlace searches. Examples: `price_high=200000000` (max price ¥), `menseki_low=40` (min area m²), `madori=1LDK` (layout), `ekimin=10` (max walk minutes), `chiku=10` (max building age).

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

🔢 Maximum listings to return per run. **FREE users:** capped at 25 · **PAID users:** unlimited.

## `useProxy` (type: `boolean`):

🌐 Route requests through a Japan residential proxy. **Off by default** — nomu is reachable without a proxy, so leaving this off keeps runs fast and cheap. Enable only if you hit a geo-block or rate-limit.

## Actor input object example

```json
{
  "scrapeMode": "overview",
  "searchMode": "byPlace",
  "propertyType": "mansion",
  "places": [
    "13101"
  ],
  "pref": "tokyo",
  "searchUrls": [
    "https://www.nomu.com/mansion/area_tokyo/13101/"
  ],
  "listingUrls": [
    "https://www.nomu.com/mansion/id/FD1C5001/"
  ],
  "maxResults": 100,
  "useProxy": false
}
```

# Actor output Schema

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

All scraped nomu listings as a clean JSON/CSV dataset.

# 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 = {
    "scrapeMode": "overview",
    "searchMode": "byPlace",
    "propertyType": "mansion",
    "places": [
        "13101"
    ],
    "pref": "tokyo",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/nomu-property-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 = {
    "scrapeMode": "overview",
    "searchMode": "byPlace",
    "propertyType": "mansion",
    "places": ["13101"],
    "pref": "tokyo",
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/nomu-property-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 '{
  "scrapeMode": "overview",
  "searchMode": "byPlace",
  "propertyType": "mansion",
  "places": [
    "13101"
  ],
  "pref": "tokyo",
  "maxResults": 100
}' |
apify call sian.agency/nomu-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "nomu Scraper — Japan Real Estate Data & API",
        "description": "nomu (ノムコム) scraper & real estate data API for Nomura's Japanese property portal. Used-condo (中古マンション) sale listings: price, layout, area, floor, building age, station access, management & repair fees, transaction terms, photos — clean JSON/CSV. Fast overview or full detail. No nomu account needed.",
        "version": "1.0",
        "x-build-id": "lpQNxgfUjTnCvGHB1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~nomu-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-nomu-property-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~nomu-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-nomu-property-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~nomu-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-nomu-property-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": {
                    "scrapeMode": {
                        "title": "🧭 Scrape mode",
                        "enum": [
                            "overview",
                            "detail"
                        ],
                        "type": "string",
                        "description": "🧭 **OVERVIEW** (cheap, primary): listing cards from the search results — price, layout, area, floor, building age, location, station access, highlight & thumbnails. The cards already carry ~90% of the useful fields.\n\n🔎 **DETAIL** (enrich): fetches each listing's full page for the spec table — management/repair fees, transaction terms, current status, construction, land rights, balcony area and the full photo set. Detail merges overview + detail into one record.",
                        "default": "overview"
                    },
                    "searchMode": {
                        "title": "🔀 Search mode",
                        "enum": [
                            "byPlace",
                            "bySearchUrl",
                            "byListingUrl"
                        ],
                        "type": "string",
                        "description": "🔀 How listings are discovered.\n\n- **byPlace** — give one or more nomu JIS area codes (e.g. `13101` for Chiyoda-ku, Tokyo) + a prefecture slug.\n- **bySearchUrl** — paste a ready-made nomu search URL with your filters applied in the UI (most reliable).\n- **byListingUrl** — fetch specific listings directly (DETAIL only).",
                        "default": "byPlace"
                    },
                    "propertyType": {
                        "title": "🏘️ Property type",
                        "enum": [
                            "mansion",
                            "house",
                            "land"
                        ],
                        "type": "string",
                        "description": "🏘️ Which nomu vertical to scrape.\n\n- **mansion** (中古マンション) — used condos for sale; fully supported and the default.\n- **house** (中古一戸建て) — used houses for sale.\n- **land** (土地) — land for sale.",
                        "default": "mansion"
                    },
                    "places": {
                        "title": "📍 Area codes",
                        "type": "array",
                        "description": "📍 **BY AREA CODE:** nomu JIS area codes to scrape (5-digit ward / city codes). Common codes: `13101` Chiyoda-ku, `13103` Minato-ku, `13104` Shinjuku-ku, `13113` Shibuya-ku. A 2-digit prefecture code (e.g. `14` Kanagawa) widens the search to the whole prefecture.\n\n💡 **TIP:** For precise filtering, use **bySearchUrl** instead — apply your filters in nomu's UI and paste the URL.",
                        "default": [
                            "13101"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "pref": {
                        "title": "🗾 Prefecture slug",
                        "type": "string",
                        "description": "🗾 nomu prefecture slug used with the area code path (`area_<pref>/<code>`). `tokyo` is the default; others include `kanagawa`, `osaka`, `aichi`, `fukuoka`, `hokkaido`.",
                        "default": "tokyo"
                    },
                    "searchUrls": {
                        "title": "🔗 Search URLs",
                        "type": "array",
                        "description": "🔗 **BY SEARCH URL:** Paste one or more nomu search-results URLs (the `/mansion/area_tokyo/13101/` pages). Apply all your filters in the nomu UI first, then copy the address — every supported filter is preserved.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingUrls": {
                        "title": "🏠 Listing URLs",
                        "type": "array",
                        "description": "🏠 **BY LISTING URL (DETAIL ONLY):** Paste nomu detail URLs (e.g. `https://www.nomu.com/mansion/id/FD1C5001/`) or bare bukken numbers. Used with scrapeMode = detail.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "↕️ Sort order",
                        "enum": [
                            "recommended",
                            "newest",
                            "price_asc",
                            "price_desc",
                            "area_desc",
                            "nearest_station",
                            "rail_line",
                            "location"
                        ],
                        "type": "string",
                        "description": "↕️ **OPTIONAL:** Sort the byPlace search results."
                    },
                    "filters": {
                        "title": "🎛️ Extra filters",
                        "type": "array",
                        "description": "🎛️ **OPTIONAL:** Extra nomu query filters as `key=value`, applied to byPlace searches. Examples: `price_high=200000000` (max price ¥), `menseki_low=40` (min area m²), `madori=1LDK` (layout), `ekimin=10` (max walk minutes), `chiku=10` (max building age).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "🔢 Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "🔢 Maximum listings to return per run. **FREE users:** capped at 25 · **PAID users:** unlimited.",
                        "default": 100
                    },
                    "useProxy": {
                        "title": "🌐 Use Japan residential proxy",
                        "type": "boolean",
                        "description": "🌐 Route requests through a Japan residential proxy. **Off by default** — nomu is reachable without a proxy, so leaving this off keeps runs fast and cheap. Enable only if you hit a geo-block or rate-limit.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
