# MLIT Japan Real Estate Prices Scraper (`acquistion-automation/mlit-japan-real-estate-prices-scraper`) Actor

Scrapes official Japanese real estate transaction prices from the MLIT land database by prefecture, city, and quarter. Returns each sale as a flat row with price, area, building age, layout, and zoning. No API key required.

- **URL**: https://apify.com/acquistion-automation/mlit-japan-real-estate-prices-scraper.md
- **Developed by:** [Acquisition Automation Co.](https://apify.com/acquistion-automation) (community)
- **Categories:** Automation, Integrations, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 results

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

![Acquisition Automation Co. Search less. Close more.](https://api.apify.com/v2/key-value-stores/AOdPHdOpeDpzEPS5f/records/banner.jpg)

## 🗾 MLIT Japan Real Estate Prices Scraper

> **Export actual transaction prices from Japan's official land price database as flat rows: what a property sold for, its area, year built, structure, zoning, nearest station and the quarter the deal closed.** Filter by prefecture, city and quarter range. In English, with no API key and no account.

Japan's Ministry of Land, Infrastructure, Transport and Tourism collects the price of recorded property transactions and publishes them. This is closed transaction data, not asking prices, which makes it the reference any valuation of Japanese property eventually has to argue with. The public portal answers one prefecture at a time, twenty rows per page, with no export. This Actor walks that search and writes each sale into a dataset as 19 fields.

| Who uses it | What they use the prices for |
|---|---|
| 🏢 Buyers of Japanese businesses with property | Testing the real estate on a target's balance sheet against what comparable buildings actually sold for |
| 🌏 Cross-border investors and funds | Pricing a market by ward and quarter before committing, without reading a Japanese portal |
| 🏦 Appraisers and lenders | Building a comparables table with area, year built, structure and zoning attached to each price |
| 📊 Analysts and researchers | Tracking price movement in a city across quarters, in English, as rows rather than PDF tables |

### 📋 What it does

> 💡 **Why it matters:** listing sites carry what sellers hope for. This carries what buyers paid. When a seller's balance sheet values a Chiyoda condo, the closed prices for the same ward in the same quarter are the argument.

- 🗾 **Selects a prefecture** by MLIT code, from `01` Hokkaido to `13` Tokyo and `27` Osaka, and optionally narrows to one city with a five digit city code.
- 📆 **Sets a quarter range.** `from` and `to` take `YYYYN` format, so `20231` to `20234` is all four quarters of 2023.
- 💴 **Returns the transaction price in yen** as a number, with the unit price per square metre where MLIT publishes one.
- 🏗 **Carries the building facts**: area, total floor area, year built and structure, for example `RC` for reinforced concrete.
- 🚉 **Names the nearest station and the walk time**, which is how Japanese property is priced in practice.
- 🗺 **Records the zoning** in `landUse`, for example `Commercial Zone`.
- 📦 **One row per transaction**, the same 19 fields every run, exportable as CSV, Excel, JSON or XML.

### 📊 Output

Every transaction is one flat row. `null` means MLIT publishes no number for that field on that record, and an empty string means the field exists but was left blank. Both are common: a pre-owned condominium record carries no `pricePerSqm` or `buildingArea`.

| Field | Type | Description |
|---|---|---|
| 🗾 `prefecture` | string | Prefecture in English, for example `Tokyo` |
| 🏙 `city` | string | City or ward in English, for example `Chiyoda Ward` |
| 📍 `district` | string | District within the city, for example `Iwamotocho` |
| 🏷 `type` | string | Property type, for example `Pre-owned Condominiums, etc.` |
| 📝 `transactionType` | string | Transaction description where MLIT publishes one, otherwise empty |
| 💴 `price` | number | Total transaction price in yen |
| 📐 `pricePerSqm` | number | Unit price per square metre in yen, where published |
| 📏 `area` | number | Area in square metres |
| 🏢 `buildingArea` | number | Total floor area of the building in square metres, where published |
| 📅 `yearBuilt` | integer | Year of construction |
| 🧱 `structure` | string | Building structure, for example `RC` |
| 🗺 `landUse` | string | Zoning at the time of the transaction, for example `Commercial Zone` |
| 🔮 `futureUse` | string | Intended future use where MLIT publishes one, otherwise empty |
| 🚉 `nearestStation` | string | Nearest station name in English |
| 🚶 `distanceToStation` | string | Walk time to that station, for example `4minutes` |
| 📆 `transactionPeriod` | string | Quarter the transaction was recorded in, for example `1st quarter 2023` |
| 🔢 `serialNumber` | integer | MLIT's own serial number for the record. It repeats across rows and is not a unique key |
| 🕒 `scrapedAt` | string | ISO timestamp of collection |
| ⚠️ `error` | string | `null` on a normal row |

#### Example rows

```json
{
  "prefecture": "Tokyo",
  "city": "Chiyoda Ward",
  "district": "Iwamotocho",
  "type": "Pre-owned Condominiums, etc.",
  "transactionType": "",
  "price": 46000000,
  "pricePerSqm": null,
  "area": 35,
  "buildingArea": null,
  "yearBuilt": 2020,
  "structure": "RC",
  "landUse": "Commercial Zone",
  "futureUse": "",
  "nearestStation": "Iwamotocho",
  "distanceToStation": "4minutes",
  "transactionPeriod": "1st quarter 2023",
  "serialNumber": 99,
  "scrapedAt": "2026-09-14T17:25:16.714Z",
  "error": null
}
```

```json
{
  "prefecture": "Tokyo",
  "city": "Chiyoda Ward",
  "district": "Iwamotocho",
  "type": "Pre-owned Condominiums, etc.",
  "transactionType": "",
  "price": 100000000,
  "pricePerSqm": null,
  "area": 75,
  "buildingArea": null,
  "yearBuilt": 2013,
  "structure": "RC",
  "landUse": "Commercial Zone",
  "futureUse": "",
  "nearestStation": "Kodemmacho",
  "distanceToStation": "4minutes",
  "transactionPeriod": "1st quarter 2023",
  "serialNumber": 99,
  "scrapedAt": "2026-09-14T17:25:16.827Z",
  "error": null
}
```

### ✨ Why choose this Actor

| | What you get |
|---|---|
| **Closed prices, not asking prices** | The source is the ministry's record of what transactions were reported at. |
| **English field values** | Prefecture, city, district, type, structure, zoning and station all come back in English. |
| **Quarter range in one run** | Set `from` and `to` and the Actor pages through the results for you, twenty rows at a time. |
| **No credentials** | The portal is public. No API key, no account, no Japanese address required to register. |
| **You pay per row** | No subscription. A quarter with no transactions costs nothing. |

### 🚀 How to use it

1. [Create a free Apify account](https://console.apify.com/sign-up). New accounts start with $5 of credit.
2. Open the Actor and select **Try for free**.
3. Pick a `prefectureCode`, and add a five digit `cityCode` if you want one city.
4. Set `from` and `to` in `YYYYN` format, then set `maxItems`.
5. Select **Start**, then export from the **Dataset** tab as CSV, Excel, JSON or XML.

A first run, Tokyo through 2023:

```json
{
  "prefectureCode": "13",
  "from": "20231",
  "to": "20234",
  "maxItems": 10
}
```

One Osaka city, two years of transactions:

```json
{
  "prefectureCode": "27",
  "cityCode": "27100",
  "from": "20221",
  "to": "20234",
  "maxItems": 2000
}
```

### ⚙️ Input

| Field | Required | Description |
|---|---|---|
| `prefectureCode` | No | MLIT prefecture code, `01` to `47`. For example `01` Hokkaido, `13` Tokyo, `27` Osaka |
| `cityCode` | No | Five digit MLIT city code. Leave empty for the whole prefecture |
| `from` | No | Start period in `YYYYN` format, where `N` is the quarter. `20221` is Q1 2022 |
| `to` | No | End period in `YYYYN` format |
| `maxItems` | No | How many transactions to collect per run. Free plans are capped at 10 as a preview, paid plans go to 1,000,000 |

### 💰 Pricing

Pay per result. No subscription, and no Apify platform usage on top.

| Apify plan | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---|---|---|---|---|---|
| Per transaction row | $0.0085 | $0.00817 | $0.00783 | $0.0075 | $0.0075 | $0.0075 |

| Rows collected | Cost on the Free plan |
|---|---|
| 100 | $0.85 |
| 1,000 | $8.50 |
| 10,000 | $85.00 |

**Free plan runs** return up to 10 rows as a preview. Any paid Apify plan lifts that to 1,000,000 per run.

### 🔌 Integrate with any app

The dataset is available through the Apify API as soon as the run finishes. Use `run-sync-get-dataset-items` for a one-shot call, webhooks to trigger what happens next, or the Make, Zapier, Airbyte and LangChain integrations listed on the Actor page.

### 🤖 Use with an AI agent

Give an agent live access to Japanese transaction prices over the Model Context Protocol:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=acquistion-automation/mlit-japan-real-estate-prices-scraper"
```

Then ask it in plain language what condominiums sold for in a ward last year and read the rows back.

### ❓ Frequently asked questions

**Are these asking prices or sale prices?**
Sale prices. MLIT publishes transaction data reported after the fact, which is why the most recent quarters take time to appear.

**Why is `pricePerSqm` or `buildingArea` `null`?**
MLIT does not publish every field for every property type. Pre-owned condominium records typically carry `price` and `area` but no unit price and no total floor area. Divide `price` by `area` if you need a rate on those rows.

**Why are `transactionType` and `futureUse` empty?**
Those fields are published for some records and left blank on others. An empty string is what the source returned, not a collection failure.

**Is `serialNumber` a unique id?**
No. It is MLIT's own serial value and it repeats across rows. Use prefecture, city, district, period, price and area together if you need to deduplicate.

**Where do I find city codes?**
`cityCode` is the five digit MLIT municipality code, which starts with the two digit prefecture code. Leave it empty to get the whole prefecture and read the codes off the results.

**What can I export?**
CSV, Excel, JSON and XML from the run page, or JSON straight from the API.

### 🔗 More from Acquisition Automation Co.

- [OLX Polska Scraper](https://apify.com/acquistion-automation/olx-polska-scraper)
- [DANE Colombia Statistics Scraper](https://apify.com/acquistion-automation/dane-colombia-statistics-scraper)
- [AIA Architect Finder Scraper](https://apify.com/acquistion-automation/aia-architect-finder-scraper)
- [PublicSurplus Scraper](https://apify.com/acquistion-automation/publicsurplus-scraper)
- [BizBuySell Scraper](https://apify.com/acquistion-automation/bizbuysell-scraper)

### About Acquisition Automation Co.

We build automation for people buying businesses. The repetitive part of an acquisition search, checking listings, pulling public records, tracking owners and assets, is work a machine should do, so the buyer's time goes into judging deals instead of collecting them.

We add new Actors regularly. If there is a source you need and do not see here, tell us.

### 🆘 Support

Open an issue in the **Issues** tab of this Actor with your run ID, the input you used, and what you expected to get back.

### ⚠️ Disclaimer

This Actor is independent and is not affiliated with, endorsed by, or sponsored by the Ministry of Land, Infrastructure, Transport and Tourism of Japan or any government agency. It collects only publicly available data and is not a valuation or an appraisal. You are responsible for using that data in compliance with the source's terms of service and applicable law.

# Actor input Schema

## `prefectureCode` (type: `string`):

MLIT prefecture code (01 Hokkaido, 13 Tokyo, 27 Osaka, etc.).

## `cityCode` (type: `string`):

Optional 5-digit MLIT city code.

## `from` (type: `string`):

Start period in YYYYN format. YYYY is year, N is quarter 1-4. Example 20221 = Q1 2022.

## `to` (type: `string`):

End period in YYYYN format.

## `maxItems` (type: `integer`):

How many transactions to collect per run.

## Actor input object example

```json
{
  "prefectureCode": "13",
  "from": "20231",
  "to": "20234",
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "from": "20231",
    "to": "20234",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("acquistion-automation/mlit-japan-real-estate-prices-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 = {
    "from": "20231",
    "to": "20234",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("acquistion-automation/mlit-japan-real-estate-prices-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "from": "20231",
  "to": "20234",
  "maxItems": 10
}' |
apify call acquistion-automation/mlit-japan-real-estate-prices-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,acquistion-automation/mlit-japan-real-estate-prices-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/dqg1zSK85hAZMFd68/builds/XJeza3Rtt4UfRyaGk/openapi.json