# LIFULL HOME'S Japan Home Prices by City and Building Age (`jpmarketdata/lifull-homes-property-price-checker`) Actor

Enter a Japanese city and see what homes cost to buy on LIFULL HOME'S. You get the site's own average price for a 70 m² condo, price per m², the same figure for seven nearby cities, and how much less older buildings ask. $0.02 per city and home type. No results = no charge. Unofficial.

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

## Pricing

from $20.00 / 1,000 market summary — one city × home types

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

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

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

# README

## LIFULL HOME'S Japan Home Prices by City and Building Age

> **Unofficial** — independent tool, **not affiliated with, endorsed by, or sponsored by LIFULL HOME'S**. It reads only publicly visible pages. Support, reliability guarantees and the full disclaimer are at the bottom of this page.

**What it does:** Name a Japanese city and get what homes cost to buy there on LIFULL HOME'S — the site's own published average, not a re-derivation of it.

**You enter:** a city, written the way the site writes it — `tokyo/shibuya-city` (渋谷区), `osaka/kita-ku-osakashi` (大阪市北区) — or the whole list page address pasted out of your browser.

**You get:** LIFULL's own average price for a 70 m² used condo and its price per m², the same average for seven neighbouring cities, the same average split into building-age bands (how much less a 20-year-old building asks), how many homes are listed and how many are new, and the typical asking price and range from the listings read on the first page.

**Price:** $0.02 per city and home type. +$0.002 per row if you also want the list. No results = no charge.

**Example:** enter `tokyo/shibuya-city` → LIFULL's own average ¥144,420,000 for a 70 m² condo (¥2,063,143 per m²) · buildings over 20 years old ask **61.8% less** than 1–3 year ones · 868 homes listed, 106 of them new · asking prices on the first page ran ¥28,500,000 to ¥379,900,000, middle ¥150,000,000 across the 41 read (real run, 2026-09-09)

> Unofficial — not affiliated with LIFULL HOME'S. Reads public pages only.

### Pricing — $0.02 per city

| Event | Price | When |
|---|---|---|
| City price summary | **$0.02** | Per city and home type analyzed |
| Individual listing | **$0.002** | Only if you turn on **Also return each listing as a row** |

A default run (1 city, used condos, summary only) costs **$0.02**, makes one read of the site and takes about 2 seconds. You pay per city; there is no monthly fee. **A city that returns zero listings is never charged**, and neither is a city path the site has no page for.

Three cities is three charges, not one — every city and home type pair is its own $0.02. A run is capped at 5 cities, so it cannot reach the platform's **$3.00 Maximum cost per run**.

### Input

| Field | Example | Notes |
|---|---|---|
| `areas` | `["tokyo/shibuya-city"]` | The site's own `prefecture/city` path, or a whole list page address pasted out of your browser. Up to 5 per run. $0.02 each |
| `propertyType` | `"used_condo"` | `used_condo`, `used_house` or `land`. One per run. Condos are averaged over 70 m² of living space, houses over 100 m² of building, and land has no published average at all |
| `sortBy` | `"address"` | Which listings the yen figures are measured on: `address` (neutral), `price_low`, `price_high`, `newest`, `area_large`, or `price_per_tsubo_low` on land pages. Echoed back as `sortUsed` |
| `pagesPerArea` | `1` | 1 or 2. One page is about 30–49 listings. Cities × pages may not exceed 5 |
| `includeIndividualListings` | `false` | Turn on to also get every listing that was read, one row each (+$0.002 per row) |
| `convertToUsd` | `true` | Adds US dollar figures at today's rate. A failed lookup never fails the run |

### The average is LIFULL's, the median is ours

Two different numbers sit in every row, and they are made in two different ways:

- **`siteBenchmarkPriceJpy`** is the figure **LIFULL publishes themselves** on the page: their own aggregate of the past three months of listings, normalised to a 70 m² condo (100 m² of building for a house), refreshed once a month. `siteBenchmarkUpdatedOn` carries the date of that refresh — `2026-09-01` in the example below — so you always know how fresh it is. The same figure comes back for seven neighbouring cities in `nearbyAreas` and for each building-age band in `byBuildingAge`. No amount of listing-reading reproduces these; they are LIFULL's arithmetic, republished with the date attached.
- **`priceJpy`** and **`pricePerSqmJpy`** are measured here, from the listings actually on the page that was read — `sampledListings` says how many. `priceJpyBasis` is `sample` unless the pages read held every listing the site counted, in which case it is `exact`.

**`benchmarkVsSampleGapPct`** is the distance between the two (+16.4% in the example). A gap is normal and informative rather than an error: the site's average is a fixed 70 m² across three months, while the sample is whatever sizes are on the page today (`medianAreaSqm` 59.12 m² there). A gap that suddenly triples is the interesting signal.

### Building-age bands

Six bands always render on the page: 1–3, 3–5, 5–10, 10–15, 15–20 years and 20+. A band with too little behind it renders as a dash, not a zero — measured 2026-09-08, Shibuya used houses had three empty bands including the newest one. Empty bands are left out of `byBuildingAge` rather than reported as ¥0, `buildingAgeBaseBand` names the band the percentages are measured against, and `oldestBandDiscountPct` is empty whenever the site left the newest or the oldest band blank.

### Output example (`type: "area_price_summary"`)

Measured on 2026-09-09 (real run, `{"areas": ["tokyo/shibuya-city"], "propertyType": "used_condo", "sortBy": "address", "pagesPerArea": 1, "includeIndividualListings": false, "convertToUsd": false}`). The whole row, nothing shortened.

```json
{
  "type": "area_price_summary",
  "area": "tokyo/shibuya-city",
  "areaPath": "tokyo/shibuya-city",
  "areaLabel": "渋谷区",
  "cityCode": "13113",
  "propertyType": "used_condo",
  "areaStatus": "ok",
  "sortUsed": "addr",
  "pagesRead": 1,
  "totalListingsFound": 868,
  "totalListingsFoundBasis": "agency_postings",
  "newListings": 106,
  "newListingShare": 0.1221,
  "siteBenchmarkPriceJpy": 144420000,
  "siteBenchmarkPerSqmJpy": 2063143,
  "siteBenchmarkBasisSqm": 70,
  "siteBenchmarkUpdatedOn": "2026-09-01",
  "siteBenchmarkNote": "LIFULL HOME'S publishes this average itself. It is their own aggregate over the past three months of listings on the site, refreshed once a month (see siteBenchmarkUpdatedOn), and it is a guide rather than a valuation of any one home.",
  "nearbyAreas": [
    {
      "areaLabel": "港区",
      "areaPath": "tokyo/minato-city",
      "priceJpy": 179850000,
      "perSqmJpy": 2569286,
      "vsThisAreaPct": 24.5
    },
    {
      "areaLabel": "新宿区",
      "areaPath": "tokyo/shinjuku-city",
      "priceJpy": 102330000,
      "perSqmJpy": 1461857,
      "vsThisAreaPct": -29.1
    },
    {
      "areaLabel": "品川区",
      "areaPath": "tokyo/shinagawa-city",
      "priceJpy": 110640000,
      "perSqmJpy": 1580571,
      "vsThisAreaPct": -23.4
    },
    {
      "areaLabel": "目黒区",
      "areaPath": "tokyo/meguro-city",
      "priceJpy": 90890000,
      "perSqmJpy": 1298429,
      "vsThisAreaPct": -37.1
    },
    {
      "areaLabel": "世田谷区",
      "areaPath": "tokyo/setagaya-city",
      "priceJpy": 77930000,
      "perSqmJpy": 1113286,
      "vsThisAreaPct": -46.0
    },
    {
      "areaLabel": "中野区",
      "areaPath": "tokyo/nakano-city",
      "priceJpy": 87760000,
      "perSqmJpy": 1253714,
      "vsThisAreaPct": -39.2
    },
    {
      "areaLabel": "杉並区",
      "areaPath": "tokyo/suginami-city",
      "priceJpy": 66920000,
      "perSqmJpy": 956000,
      "vsThisAreaPct": -53.7
    }
  ],
  "byBuildingAge": [
    {
      "ageBand": "1〜3年以内",
      "avgPriceJpy": 276070000,
      "perSqmJpy": 3943857,
      "vsNewestPct": 0.0
    },
    {
      "ageBand": "3〜5年以内",
      "avgPriceJpy": 248300000,
      "perSqmJpy": 3547143,
      "vsNewestPct": -10.1
    },
    {
      "ageBand": "5〜10年以内",
      "avgPriceJpy": 172890000,
      "perSqmJpy": 2469857,
      "vsNewestPct": -37.4
    },
    {
      "ageBand": "10〜15年以内",
      "avgPriceJpy": 163970000,
      "perSqmJpy": 2342429,
      "vsNewestPct": -40.6
    },
    {
      "ageBand": "15〜20年以内",
      "avgPriceJpy": 149370000,
      "perSqmJpy": 2133857,
      "vsNewestPct": -45.9
    },
    {
      "ageBand": "20年以上",
      "avgPriceJpy": 105350000,
      "perSqmJpy": 1505000,
      "vsNewestPct": -61.8
    }
  ],
  "buildingAgeBaseBand": "1〜3年以内",
  "oldestBandDiscountPct": -61.8,
  "sampledListings": 41,
  "priceJpy": {
    "min": 28500000,
    "p25": 99800000,
    "median": 150000000,
    "p75": 215000000,
    "max": 379900000,
    "average": 161727805
  },
  "priceJpyBasis": "sample",
  "pricedListings": 41,
  "priceUsd": null,
  "exchangeRateJpyUsd": null,
  "pricePerSqmJpy": {
    "min": 1150325,
    "p25": 1934802,
    "median": 2400662,
    "p75": 3052551,
    "max": 3631584,
    "average": 2418251
  },
  "sampleAreaBasis": "exclusive floor area",
  "medianAreaSqm": 59.12,
  "medianBuildingAgeYears": 15,
  "medianUnitsInBuilding": 29,
  "medianWalkMinutes": 4,
  "layoutMix": [
    {
      "layout": "2LDK",
      "count": 20
    },
    {
      "layout": "1LDK",
      "count": 7
    },
    {
      "layout": "3LDK",
      "count": 5
    },
    {
      "layout": "2SLDK",
      "count": 3
    },
    {
      "layout": "2DK",
      "count": 2
    },
    {
      "layout": "1SLDK",
      "count": 2
    },
    {
      "layout": "ワンルーム",
      "count": 1
    },
    {
      "layout": "1K",
      "count": 1
    }
  ],
  "duplicateListingSharePct": 2.4,
  "benchmarkVsSampleGapPct": 16.4,
  "hint": null,
  "sourceUrl": "https://www.homes.co.jp/mansion/chuko/tokyo/shibuya-city/list/?cond%5Bsortby%5D=addr",
  "checkedAt": "2026-09-09T01:39:53.046985+00:00"
}
```

With **Also return each listing as a row** on, each listing that was read is one extra row:

```json
{
  "type": "listing",
  "area": "tokyo/shibuya-city",
  "areaPath": "tokyo/shibuya-city",
  "propertyType": "used_condo",
  "buildingName": "グランスイート神宮前",
  "listingUrl": "https://www.homes.co.jp/mansion/b-1421770025495/",
  "priceJpy": 128000000,
  "areaSqm": 46.53,
  "areaBasis": "exclusive floor area",
  "pricePerSqmJpy": 2750913,
  "layout": "1LDK",
  "floor": 10,
  "builtYearMonth": "2005年02月",
  "buildingAgeYears": 22,
  "unitsInBuilding": 42,
  "structure": "RC(鉄筋コンクリート) / 12階建",
  "station": "JR山手線 原宿駅 徒歩7分",
  "walkMinutes": 7,
  "addressLine": "東京都渋谷区神宮前1丁目1-5"
}
```

Example values (shape only — numbers are illustrative).

### What this Actor does not do

- **No agency contact details.** No agency name, no phone number, no property-information manager's name. Every rival tool on this site returns them; this one is built for research, not for sales leads.
- **No photos.** Image addresses are never returned.
- **No rentals.** This is the buy side (`/mansion/chuko/`, `/kodate/chuko/`, `/tochi/`). Rents are a different product.
- **No sold prices.** These are asking prices for homes currently listed, not what anything actually sold for.
- **No valuation of your home.** LIFULL's own footnote says the average is a guide and that floor, layout and walking distance move a real price away from it; `siteBenchmarkNote` carries that in every row.
- **No more than 5 reads of the site per run.** See below.

### Notes on the data

- **What "868 listings" counts.** The site counts agency postings, not homes: one apartment listed by three agencies is three. `totalListingsFoundBasis` says `agency_postings` on every row, and `duplicateListingSharePct` measures how much of the sample read is the same home twice (2.4% in the example).
- **What "new" counts.** `newListings` comes from the site's own new-listings banner and nothing else. Every listing row on the page carries a CSS class called `new`, which is decoration, not a flag — reading it would report 41 of 41 as new.
- **The listing count is cross-checked three ways.** The page publishes it in a `totalNum` span, a hidden `quantity` field and its analytics data. All three are read, and a disagreement fails the run instead of picking a winner.
- **The order is always chosen.** The site's own default puts paid placements first. An order is sent on every read and echoed as `sortUsed`, so the yen figures are never measured on an advertising order by accident.
- **Page size is not a fixed listing count.** A page is 30 building groups while the count is per posting, so one condo page holds about 31–49 listings. `sampledListings` is the honest number of listings the yen figures were measured on.
- **Five reads per run, and that is permanent.** The site's protection turns an address away after six reads, whatever the spacing between them (measured at 2 seconds and at 12 seconds, from two different networks, 2026-09-08). This Actor stops at five, refuses an input that would need more, and if it is turned away anyway it stops and says so in plain words rather than reporting an empty result. The block clears on its own in about ten minutes, so a run that fails is worth repeating a few minutes later.
- **Land is different.** Land pages carry no published average and no new-listings banner at all — `siteBenchmark*` and `newListings` come back empty, and the yen figures are measured on land area. That is a normal land page, not a failure.
- **Transport.** Plain server-rendered pages, UTF-8, gzip, no login and no cookie needed. About 600 KB per page. 2 seconds between reads; the site's `robots.txt` asks for no delay and does not bar these pages.

### If something goes wrong

- **Wrong number or a failed run?** Open a ticket on the **Issues** tab. I read every one and reply within 2 business days (Japan time).
- **You never get a fake "empty" result.** If the site can't be read, the run fails and says so.
- **No results = no charge.** You only pay for results you actually get.
- **Checked every week.** An automatic test runs this tool weekly; if the site changes, I fix it.
- **Public pages only.** No login, no personal data, and it goes easy on the site.

### More tools by the same author

- [at home Japan Rent Prices by Area — Fees & Deposits](https://apify.com/jpmarketdata/athome-rent-market-checker)
- [SUUMO vs at home — Japan Rent by Ward, Two Sites Compared](https://apify.com/jpmarketdata/japan-rent-market-benchmark)
- [SUUMO Japan Rent & Used Condo Prices by City + Gross Yield](https://apify.com/jpmarketdata/suumo-market-checker)
- [Yahoo! Real Estate Japan Used Condo Prices by Area](https://apify.com/jpmarketdata/yahoo-realestate-condo-market-checker)
- [Mercari Japan Sold Prices — What Items Really Sell For](https://apify.com/jpmarketdata/mercari-japan-price-checker)
- [Yahoo! Auctions Japan Sold Prices — Median, Range, Bids](https://apify.com/jpmarketdata/yahoo-auction-sold-comps)

All tools (Japan marketplaces, real estate, jobs, racing, prediction markets): <https://apify.com/jpmarketdata>

### Disclaimer

Unofficial, independent tool — **not affiliated with, endorsed by, or sponsored by LIFULL HOME'S**. Product names and logos belong to their owners and only say where the data comes from. Data is read from public pages, for market research; check before you act on it.

# Actor input Schema

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

One row of numbers per city. Each city is charged $0.02, and a city with nothing listed is not charged. Write a city the way the site does, `prefecture/city`: `tokyo/shibuya-city`, `osaka/kita-ku-osakashi`. A pasted list page address works too. At most 5 cities per run — the site turns an address away after six reads — so a run cannot reach the $3.00 Maximum cost per run.

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

One home type per run: each extra type is another read of the site, and a run only gets five. Used condos are averaged over 70 m² of living space and used houses over 100 m² of building, so the two averages are different measurements. Land has no published average on this site — you get the count and the yen figures, and the average fields come back empty. It does not change what you are charged.

## `sortBy` (type: `string`):

Which listings the yen figures are measured on. The site's own default puts paid placements first and is not price-neutral, so an order is always chosen here and the row says which one in `sortUsed`. Address order is the neutral one. Cheapest per tsubo exists only on land pages and falls back to address order elsewhere. The city average and the neighbour and building-age tables never move with it.

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

How many listings the yen figures are measured on. One page is about 30 to 49 listings and costs one read of the site; two pages doubles both. Cities times pages may not exceed 5 or the run stops before it starts, because the site turns an address away after six reads. With individual listings on, a second page is about 30 to 49 more rows at $0.002 each.

## `includeIndividualListings` (type: `boolean`):

Off by default: a run costs a flat $0.02 per city and home type. Turn it on to also get the listings that were read, one row each, at +$0.002 per row — building name, link, price, size, price per m², layout, floor, build year, building age, homes in the building, structure, nearest station, walk minutes and street. Agency names, phone numbers and photos are never returned, on or off.

## `convertToUsd` (type: `boolean`):

Adds a US dollar copy of the yen price figures at today's rate. A failed rate lookup never fails the run — you simply get the yen numbers on their own.

## Actor input object example

```json
{
  "areas": [
    "tokyo/shibuya-city"
  ],
  "propertyType": "used_condo",
  "sortBy": "address",
  "pagesPerArea": 1,
  "includeIndividualListings": false,
  "convertToUsd": true
}
```

# Actor output Schema

## `areaPriceSummaries` (type: `string`):

What homes cost to buy in one Japanese city on LIFULL HOME'S. Turn on individual listings and each home that was read is an extra row.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "areas": [
        "tokyo/shibuya-city"
    ],
    "propertyType": "used_condo",
    "sortBy": "address",
    "pagesPerArea": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("jpmarketdata/lifull-homes-property-price-checker").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "areas": ["tokyo/shibuya-city"],
    "propertyType": "used_condo",
    "sortBy": "address",
    "pagesPerArea": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("jpmarketdata/lifull-homes-property-price-checker").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 '{
  "areas": [
    "tokyo/shibuya-city"
  ],
  "propertyType": "used_condo",
  "sortBy": "address",
  "pagesPerArea": 1
}' |
apify call jpmarketdata/lifull-homes-property-price-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jpmarketdata/lifull-homes-property-price-checker"
        }
    }
}

```

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/2rybN40lR0EJCiWb9/builds/LteVhOlj4nsCXPHQ2/openapi.json