# Livable Scraper: Tokyu Livable Japan Real Estate Listings (`recordsdata/livable-scraper`) Actor

Scrape Tokyu Livable (livable.co.jp), a Japan real estate agency portal: used and new condominiums, houses, land and rentals with price in JPY, address, station walk, layout, area, coordinates, fees, photos and branch. Filter by city, price, size, layout. Export CSV, Excel, JSON, XML.

- **URL**: https://apify.com/recordsdata/livable-scraper.md
- **Developed by:** [RecordsData](https://apify.com/recordsdata) (community)
- **Categories:** Real estate, Lead generation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $22.00 / 1,000 property listings

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?

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

![RecordsData](https://api.apify.com/v2/key-value-stores/AAm3a1h3Z9nYfrvh9/records/banner?v=3)

## Livable Scraper: Tokyu Livable Japan Real Estate Listings

Livable Scraper turns the search pages of livable.co.jp, the portal of Tokyu Livable (東急リバブル), into a clean dataset. Tokyu Livable lists properties for sale in 20 prefectures and rentals in 9. The Actor reads those pages at a polite pace and returns one typed row per property.

> Livable Scraper is an Apify Actor that exports the property listings of livable.co.jp as structured data: used and new condominiums, houses, land and rentals with price in JPY, price per square meter, address, coordinates, station walk, layout, floor area, fees, building age, photos, agency branch and posting dates. It also reads branch pages and condominium building pages. Filter by prefecture, city, price, size, layout, walk and building age. No login and no proxy. Pay per result.

Export the result as JSON, CSV, Excel, XML or HTML, or read it through the Apify API.

### What can you scrape from livable.co.jp?

- **Listings (`listing`)**: one row per property for sale or rent: used condominiums, new condominiums, used houses, new houses, land, new-build projects and rentals.
- **Branches (`agency`)**: one row per Tokyu Livable office, with address, opening hours, regular holiday, customer rating, review count and services.
- **Buildings (`building`)**: one row per condominium building page, with structure, builder, total units, and how many units are for sale or for rent.

### Why use this Livable scraper?

- **Price per square meter computed for you**: `pricePerM2` sits next to the price in JPY, the price text as the site writes it (for example 5,299万円), and the price unit (`total` or `month`).
- **Exact filters**: the site filters on fixed steps only. The Actor widens your bounds to the nearest step the site accepts, then applies your exact bounds to every listing, so every row fits what you asked for.

### How to scrape livable.co.jp in four steps

1. Create a free account at console.apify.com and open this Actor.
2. Choose **For sale** or **For rent**, the prefecture, and optionally the cities or wards and filters such as price, area, layout, walk to the station, building age, price reduced, newly listed and renovated.
3. Set **Max items** and press Start. Leave the cities empty to search every city with listings, the busiest first.
4. Download the dataset from the **Storage** tab as CSV, Excel, JSON or XML.

To reuse a search, paste its address in **Start URLs**, for example `https://www.livable.co.jp/chintai/tokyo/a13103/` for rentals in Minato ward. You can also paste a single listing page, a new-build project page, a branch page or a building page.

### Input

The form has 24 fields, the main ones are. All of them:

| Field | Type | Default | Meaning |
|---|---|---|---|
| `startUrls` | array | empty | Search, listing, project, branch or building pages to read |
| `maxItems` | integer | none | Maximum rows, all record types together |
| `recordTypes` | array | `["listings"]` | What to return: `listings`, `agencies`, `buildings` |
| `fetchDetails` | boolean | true | Open each listing page for coordinates, all photos, fees and dates |
| `operation` | string | `sale` | `sale` or `rent` |
| `propertyTypes` | array | `["mansion","kodate","tochi"]` | Property types for sale |
| `prefecture` | string | `tokyo` | One of 20 prefectures, such as `tokyo`, `kanagawa`, `osaka` |
| `municipalities` | array | empty | Cities and wards, in Japanese (港区) or by area code (a13103) |
| `minPrice` / `maxPrice` | integer | none | Price range in JPY |
| `minArea` / `maxArea` | number | none | Floor area range in square meters |
| `layouts` | array | empty | Layouts such as 1LDK or 2LDK |
| `maxWalkMinutes` | integer | none | Maximum walk to a station |
| `maxBuildingAge` | integer | none | Maximum building age in years |
| `priceReduced` / `newlyListed` / `renovated` | boolean | false | Keep only those listings |
| `sort` | string | `recommended` | Sort order, such as `newer` or `price_low_to_high` |
| `onlyNew` | boolean | false | Monitor mode: deliver only unseen rows |
| `stateKey` / `resetSeen` | string / boolean | empty / false | Monitor name, and a reset of its memory |
| `includeContactDetails` | boolean | false | Include branch phone numbers |
| `proxyConfiguration` | object | off | Proxy, not needed |

Input for used condominiums in Minato ward within 10 minutes of a station:

```json
{
  "operation": "sale",
  "prefecture": "tokyo",
  "propertyTypes": ["chuko-mansion"],
  "municipalities": ["港区"],
  "maxWalkMinutes": 10,
  "maxItems": 100
}
```

### What data do you get from livable.co.jp?

Every row has a `recordType`: `listing`, `agency` or `building`. Rows are flat and typed, and empty values are left out instead of being filled with `null`. The dataset has 104 fields in total. Text values come back in Japanese, as the site writes them, in UTF-8.

#### Listing rows

| Field | Type | Example |
|---|---|---|
| `recordType` | string | `listing` |
| `listingId` | string | `C4826XH11` |
| `title` | string | `エクセルシオール港区海岸` |
| `price` | number | `52990000` |
| `priceText` | string | `5,299万円` |
| `pricePerM2` | number | `1542200` |
| `maintenanceFee` | number | `9280` |
| `address` | string | `東京都港区海岸2丁目6-33` |
| `latitude` | number | `35.6500787` |
| `nearestStation` | string | `浜松町` |
| `layout` | string | `1LDK` |
| `areaBuilt` | number | `34.36` |
| `yearBuilt` | number | `1998` |
| `structure` | string | `鉄筋コンクリート造` |
| `agencyName` | string | `大井町センター` |
| `agencyRating` | number | `4.8` |
| `publishedAt` | string | `2026-11-02` |

#### Branch rows

| Field | Type | Example |
|---|---|---|
| `recordType` | string | `agency` |
| `title` | string | `大井町センター` |
| `address` | string | branch address |
| `agencyHours` | string | opening hours |
| `agencyHoliday` | string | regular holiday |
| `agencyRating` | number | `4.8` |
| `agencyServices` | array | services of the branch |

#### Building rows

| Field | Type | Example |
|---|---|---|
| `buildingId` | string | building page id |
| `yearBuilt` | number | `1998` |
| `structure` | string | `鉄筋コンクリート造` |
| `totalUnits` | number | units in the building |
| `builderCompany` | string | builder |
| `forSaleCount` | number | units for sale now |
| `forRentCount` | number | units for rent now |

#### Sample output

A used condominium in Minato ward, Tokyo, read on 2026-11-02 (shortened):

```json
{
  "recordType": "listing",
  "listingId": "C4826XH11",
  "title": "エクセルシオール港区海岸",
  "operation": "sale",
  "condition": "used",
  "price": 52990000,
  "currency": "JPY",
  "priceText": "5,299万円",
  "pricePerM2": 1542200,
  "maintenanceFee": 9280,
  "address": "東京都港区海岸2丁目6-33",
  "nearestStation": "浜松町",
  "walkMinutes": 12,
  "layout": "1LDK",
  "areaBuilt": 34.36,
  "yearBuilt": 1998,
  "agencyName": "大井町センター",
  "publishedAt": "2026-11-02",
  "sourceSite": "livable.co.jp"
}
```

### Speed and proxy

No proxy is needed. livable.co.jp answers plain requests with no challenge, no login and no captcha, and the Actor keeps a pace of one request per second. If the site refuses a request several times, the Actor switches to the Apify datacenter proxy by itself. Turn **Open each listing page** off to read 30 listings per request, with card fields only.

### Monitor new listings and repricing

Switch on **Only new rows (monitor mode)** and the Actor remembers the ids it delivered, in a named key-value store of your own account. Later scheduled runs deliver only unseen listings and skip charging for the rest. Use one **Monitor name** per saved search. For repricing, enable **Price reduced only** and compare `price` between runs.

### How much does the Livable Scraper cost?

Pay per result, no monthly fee. Rates are USD per result on the Free tier.

| Event | Charged for | Per result | Per 1,000 |
|---|---|---|---|
| Listing record | One listing read from the search pages (card fields) | $0.022 | $22.00 |
| Listing detail record | One listing opened on its own page (`fetchDetails`) | $0.0275 | $27.50 |
| Agency record | One Tokyu Livable branch | $0.0275 | $27.50 |
| Building record | One condominium building | $0.0275 | $27.50 |

Worked examples: 1,000 listing records from the search pages cost $22.00. 1,000 listings with full detail pages cost $27.50. 200 branches cost 200 x $0.0275 = $5.50. Rows outside your exact filter bounds are dropped before they are counted or charged, and monitor mode skips charging for rows you already received.

### How does it compare with other livable.co.jp scrapers? Read on 2026-11-03

One other Apify Actor for the same site is listed on the Store: Tokyu Livable Scraper by sian.agency. The comparison uses what its Store page states.

| | Livable Scraper (this Actor) | Tokyu Livable Scraper (sian.agency) |
|---|---|---|
| Output fields | 104 (listings, branches, buildings) | 42 listed on its Store page |
| Rentals | Yes, 9 prefectures | Not stated, described as for-sale apartments, houses and land |
| Branch rows | Yes | Not stated |
| Condominium building rows | Yes | Not stated |
| Filters in the input | Prefecture, city, price, size, layout, walk, building age, price reduced, newly listed, renovated, sort | Not stated |
| Monitor mode for new listings | Yes | Not stated |
| Event rates | $0.022 per listing, $0.0275 per detail listing | $0.012 per overview listing, $0.025 per detail listing, $0.01 per start |

Both read the same site, so the difference is coverage, number of fields and filters. Rates drift, so check each Store page before you decide.

### Is it legal to scrape livable.co.jp? Limits and responsible use

The Actor reads the public pages that livable.co.jp shows to every visitor, without logging in, at one request per second. The robots.txt of the site does not exclude the search, listing, branch or building pages. The site's copyright notice reserves the rights to its texts and photos for Tokyu Livable, so check the site terms before republishing commercially.

Privacy is handled in the Actor. Listings on this site are posted by the agency, never by a private owner. Names of branch staff are never returned. Branch phone numbers and phone numbers written inside descriptions are removed unless you switch on **Include branch phone numbers**.

Limits:

- The site filters on fixed steps only, so a very narrow filter reads a wider list first and then trims it.
- A field that does not apply to a property type, such as a floor for a house, is absent.

### Use with AI agents (MCP)

Connect the Apify MCP server to Claude, Cursor or another MCP client and this Actor appears as a tool: `https://mcp.apify.com?tools=RecordsData/livable-scraper`.

Example prompt: "List used condominiums for sale in Setagaya ward under 80,000,000 yen within 10 minutes of a station, return the 20 cheapest per square meter with station, area and link, and tell me the median price per square meter."

### Run it from code

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('RecordsData/livable-scraper').call({ operation: 'sale', prefecture: 'tokyo', municipalities: ['港区'], maxItems: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].title, items[0].price);
```

Python client, Make, Zapier, n8n and Apify schedules also work.

### Frequently Asked Questions

#### Do I need a proxy, a login or an API key for livable.co.jp?

No. The Actor makes plain requests to public pages, needs no login, no API key and no captcha solving. The Apify proxy field exists but is off by default, and the Actor turns on the datacenter proxy by itself only if the site refuses a request several times. You only need an Apify account,.

#### How many listings does livable.co.jp have?

The number changes every day. On 2026-11-02 the site showed 550 used condominiums for sale in Minato ward, 160 houses for sale in Setagaya ward, 219 rentals in Shibuya ward and 205 rentals in Shinjuku ward. Schedule the Actor to follow the numbers over time, and use the monitor mode to receive only the new listings of each run.

#### Which prefectures and property types are covered?

Sale listings exist in 20 prefectures, including Tokyo, Kanagawa, Saitama, Chiba, Osaka, Hyogo and Kyoto, for condominiums, houses and land, used and new. Rentals exist in 9 prefectures: Tokyo, Kanagawa, Saitama, Chiba, Osaka, Hyogo, Kyoto, Shiga and Miyagi.

#### How do I search a single ward or city?

Type the Japanese name in **Cities and wards**, for example 港区 or 世田谷区, or paste the area code from the search page address, such as a13103. Leave the field empty to search every city of the prefecture that has listings.

#### Why does a price filter never return a listing outside my range?

The site only filters on fixed steps, so a price such as 52,000,000 yen or a size such as 47 square meters would be silently ignored by the site. The Actor asks for the nearest wider step, then drops every listing outside your exact bounds before it is counted or charged. The rows you get always fit the range you typed.

#### Does it return phone numbers or names of people?

Not by default. Listings are posted by Tokyu Livable branches, so there are no private sellers. Names of branch staff are never returned. Branch phone numbers and numbers written inside descriptions are removed unless you switch on **Include branch phone numbers**.

#### How do I get only new listings on a schedule?

Turn on **Only new rows (monitor mode)** and, if you run several searches, give each a name in **Monitor name**. The first run delivers the listings it finds and remembers their ids. The next runs deliver only listings that were not seen before and skip charging for the rest. Turn on **Reset monitor memory** to start over from zero.

#### Why are some columns empty in my export?

Either the listing does not state the value, or **Open each listing page** was off. The search pages carry only the card fields: price, layout, area, station, one photo and address. Coordinates, all photos, branch details, fees and exact dates need the listing page. A field that does not apply to the property type is left out of the row.

#### What is the difference between a listing, a branch and a building row?

A listing row is one property for sale or rent. A branch row is a Tokyu Livable office, with address, opening hours, holiday, rating and services. A building row is the condominium building page, with structure, builder, number of units, and how many units are for sale or for rent. Choose them in **What to return**; each has its own event rate.

#### Can I read the Japanese text, and how much does a run cost?

Titles, addresses and descriptions come back in Japanese in UTF-8, so they open correctly in JSON, CSV and Excel. A listing record costs $0.022, so 1,000 listings cost $22.00, and a listing with its detail page costs $0.0275. Rows outside your filter and monitor skips are not charged.

### Support

Questions, a missing field or a feature request: contact.punkrecordsdata@gmail.com. Reviews on the Actor page help other people find it.

This Actor is an independent tool and is not affiliated with Tokyu Livable or livable.co.jp.

Last updated: 2026-11-03

# Actor input Schema

## `operation` (type: `string`):

Search properties for sale or for rent. Rentals are listed in Tokyo, Kanagawa, Saitama, Chiba, Osaka, Hyogo, Kyoto, Shiga and Miyagi.

## `prefecture` (type: `string`):

Prefecture to search. Sale listings exist in 20 prefectures; rentals in 9 (Tokyo, Kanagawa, Saitama, Chiba, Osaka, Hyogo, Kyoto, Shiga, Miyagi).

## `propertyTypes` (type: `array`):

Types searched when buying. Condominiums and houses cover used and new; pick the narrower types (used, new) to split them. Rentals ignore this field: every rental type comes in one list.

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

How many rows to return in total (listings, branches and buildings together). Example: 10. Free plan runs are capped at 10 rows; leave empty for no limit on paid plans.

## `startUrls` (type: `array`):

Optional. Paste livable.co.jp pages instead of using the search fields. Example: https://www.livable.co.jp/kounyu/mansion/tokyo/a13121/ (search page), a listing page, a branch page or a building page. Leave empty to search with the fields above.

## `municipalities` (type: `array`):

Only these cities or wards of the prefecture: the Japanese name (for example 足立区, 世田谷区, 横浜市中区) or the area code from the search page address (a13121). Leave empty for every city with listings, the busiest first.

## `minPrice` (type: `integer`):

Lowest price in yen (for rentals, rent per month). Example: 30000000 for 30 million yen. The site filters in fixed steps and the actor applies your exact bound to every listing.

## `maxPrice` (type: `integer`):

Highest price in yen (for rentals, rent per month). Example: 80000000 for 80 million yen, or 200000 for a rent of 200,000 yen.

## `minArea` (type: `number`):

Smallest floor area in square metres (land area for land listings).

## `maxArea` (type: `number`):

Largest floor area in square metres (land area for land listings).

## `layouts` (type: `array`):

Layout groups as the site offers them. Any of the chosen groups matches. Not used for land.

## `maxWalkMinutes` (type: `integer`):

Only listings within this many minutes on foot of a station (1 to 60). Example: 10.

## `maxBuildingAge` (type: `integer`):

Only buildings completed within this many years (1 to 100). Not used for land. Example: 10.

## `priceReduced` (type: `boolean`):

Only sale listings whose price was lowered.

## `newlyListed` (type: `boolean`):

Only listings the site marks as newly listed.

## `renovated` (type: `boolean`):

Only sale listings of renovated properties (condominiums and houses).

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

Order of the search results, which decides which listings come first when Max items is small. Price sorts for rentals are the rent ones.

## `recordTypes` (type: `array`):

listings: one row per property for sale or rent. agencies: the Tokyu Livable branch behind each listing (address, hours, rating, services). buildings: the condominium building page behind each apartment (units, structure, builder, how many are for sale or rent).

## `fetchDetails` (type: `boolean`):

On: every listing page is read for the full record (coordinates, all photos, description, branch, building, exact dates, management and repair fees, land rights). Off: only what the search page shows (faster and cheaper, no coordinates or branch). Must stay on to collect branches or buildings.

## `includeContactDetails` (type: `boolean`):

Off by default. On: branch rows and listing rows carry the phone number of the Tokyu Livable branch (a business line) and phone numbers written inside descriptions are kept. Individual staff names are never returned.

## `onlyNew` (type: `boolean`):

Only new rows: skip every listing, branch or building this same search already returned in an earlier run, so a scheduled run returns just the new ones and you are not charged for skipped rows. Max Items then means N new rows. Off by default.

## `stateKey` (type: `string`):

A label to keep two monitors of the same search apart. Leave empty for one monitor per search.

## `resetSeen` (type: `boolean`):

Forget everything this search returned before and start the monitor again from now.

## `maxRunSeconds` (type: `integer`):

The actor stops reading new pages after this time and returns what it has.

## `proxyConfiguration` (type: `object`):

Not needed: the actor reads livable.co.jp directly at a polite pace (one request per second). If the site ever refuses the connection, the actor switches to the Apify datacenter proxy by itself. Switch the proxy on here to force it from the first request.

## Actor input object example

```json
{
  "operation": "sale",
  "prefecture": "tokyo",
  "propertyTypes": [
    "mansion",
    "kodate",
    "tochi"
  ],
  "maxItems": 10,
  "startUrls": [],
  "municipalities": [],
  "layouts": [],
  "priceReduced": false,
  "newlyListed": false,
  "renovated": false,
  "sort": "recommended",
  "recordTypes": [
    "listings"
  ],
  "fetchDetails": true,
  "includeContactDetails": false,
  "onlyNew": false,
  "stateKey": "",
  "resetSeen": false,
  "maxRunSeconds": 3600,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Key fields per row

## `fullData` (type: `string`):

Complete dataset with all fields

# 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 = {
    "operation": "sale",
    "prefecture": "tokyo",
    "propertyTypes": [
        "mansion",
        "kodate",
        "tochi"
    ],
    "maxItems": 10,
    "startUrls": [],
    "municipalities": [],
    "layouts": [],
    "sort": "recommended",
    "recordTypes": [
        "listings"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("recordsdata/livable-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 = {
    "operation": "sale",
    "prefecture": "tokyo",
    "propertyTypes": [
        "mansion",
        "kodate",
        "tochi",
    ],
    "maxItems": 10,
    "startUrls": [],
    "municipalities": [],
    "layouts": [],
    "sort": "recommended",
    "recordTypes": ["listings"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("recordsdata/livable-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 '{
  "operation": "sale",
  "prefecture": "tokyo",
  "propertyTypes": [
    "mansion",
    "kodate",
    "tochi"
  ],
  "maxItems": 10,
  "startUrls": [],
  "municipalities": [],
  "layouts": [],
  "sort": "recommended",
  "recordTypes": [
    "listings"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call recordsdata/livable-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,recordsdata/livable-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/OQIR2GnF0GFEosCPl/builds/1uUf8OKPtoNKxxvAv/openapi.json