# AtHome Japan Scraper \[$1.5/1K💰] | Rent | Sale | Listings (`ahmed_jasarevic/athome-co-jp-scraper`) Actor

Extract at home (athome.co.jp) rental and sale property listings across Japan — yen-normalised rent and price, deposit and key money, layout, station access, agency contacts and GPS — as structured JSON. Built for Japan rental market research. $1.50 per 1,000 listings.

- **URL**: https://apify.com/ahmed_jasarevic/athome-co-jp-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 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

## AtHome Japan Real Estate Scraper

Extract rental and sale property listings from at home (athome.co.jp) — rent and management fee, deposit and key money, layout, floor area, floor, building age, address, nearest station and walk time, agency name and phone, photos, move-in cost and GPS coordinates — as structured JSON, from $1.5 per 1,000 listings.

**Built for:**

- Japan rental market research and price monitoring
- Relocation and expat-housing platforms
- Real-estate investors pricing Tokyo and Osaka wards
- Lead generation from listing agency contacts
- Building structured property databases with coordinates

### Extract AtHome Listings For Japan Rental Market Research

Give the actor a listing type and a prefecture (for example `rent` + `tokyo`), optionally narrowed to a ward slug such as `shibuya-city`, and it walks the result pages until `maxListings` is reached. Each row is one room for rent or one building for sale, with prices already normalised to integer yen — `17.7万円` becomes `177000` — plus deposit and key money as both text (`敷金`/`礼金`) and month counts, so you can filter and sort without parsing Japanese strings.

### How It Works

![How the AtHome Scraper works: prefecture searches become room-level rental and sale rows with yen prices, deposits, access and agency contacts.](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-athome-scraper)

For each result page the Actor parses the Angular server-state JSON embedded in the HTML, which carries 30 rooms per request. With details enabled it calls AtHome's own BFF endpoint for rent, initial costs, agency phone, full photo list and coordinates.

Prices are normalized to integer yen and Japanese deposit and key-money text is translated into month counts. Each row covers one room or building with layout, area, floor, age, station access and address.

This is a pure HTTP/JSON actor on 256 MB of memory — no browser, no rendering:

1. **Listing pages** — `athome.co.jp/chintai/{prefecture}/list/page{N}/` is an Angular Universal page whose entire result set is embedded in a `<script id="serverApp-state">` JSON blob; the actor parses `first-view-ITEMS.data.propertyListData.propertyList` directly (30 rooms per request). Sale listings (`/mansion/…`, `/kodate/…`) use the same pattern under `bukkenData.bukkenList`.
2. **Detail JSON API** — for each listing the actor calls the site's own BFF endpoint `csite-bff/rent-living/property-detail/first-view?bukkenNo={id}&…`, which returns `data.propertyData` with rent info, initial costs, the agency card (`kaiinInfo`, including phone), surrounding info (lat/lng) and the full image list. No cookies or login are required. Sale listings are enriched from their detail page's `serverApp-state` blob instead.

The site may present a Geetest challenge to aggressive datacenter traffic, so keep concurrency low on large runs and enable Apify Proxy (residential recommended) for volume.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `listingType` | string | **Yes** | `rent` | `rent` (賃貸), `sale-mansion` (マンション) or `sale-house` (一戸建て). |
| `prefecture` | string | **Yes** | `tokyo` | AtHome roman prefecture slug, e.g. `tokyo`, `osaka`, `kanagawa`, `aichi`, `fukuoka`, `hokkaido`. |
| `city` | string | No | `""` | Optional city/ward slug to narrow the search, e.g. `shibuya-city`, `shinjuku-city`, `osaka-city-kita-ku`. Empty = whole prefecture. |
| `maxListings` | integer | No | `100` | Hard cap on pushed listings (rooms for rent, buildings for sale); result pages are fetched lazily until it is reached. Max 1000. |
| `includeDetails` | boolean | No | `true` | Fetch the detail JSON per listing to add agency phone, full photo list, exact address, coordinates and initial cost. Adds one request and one billed `listing-detail` event per listing. |
| `proxy` | object | No | off | Standard Apify proxy picker (residential recommended for large runs). |

### Output Fields

| Field | Description |
| --- | --- |
| `listingId`, `url` | AtHome listing (room) ID and detail URL |
| `listingType`, `propertyType`, `buildingType` | Rent/sale plus Japanese type and normalised `mansion`/`apartment`/`house`/`land` |
| `title`, `buildingName` | Listing and building titles |
| `rentYen` / `rentText`, `priceYen` / `priceText` | Monthly rent (rentals) or sale price, as integer yen and original text |
| `managementFeeYen` / `managementFeeText` | Monthly management fee (管理費) |
| `deposit`, `depositMonths`, `keyMoney`, `keyMoneyMonths` | 敷金 / 礼金, as text and month counts |
| `layout`, `areaM2` | Floor plan (間取り, e.g. `2LDK`) and exclusive area in m² |
| `floor`, `buildingAge`, `buildingAgeYears` | Unit floor and building age (築N年) |
| `address`, `ward`, `city`, `prefecture` | Full address and administrative hierarchy |
| `nearestStation`, `line`, `walkMinutes`, `access` | Nearest station, line, walking minutes and access text |
| `agentName`, `agencyPhone`, `agencyAddress`, `agencyUrl` | Listing agency and contact details |
| `photos`, `photoDetails`, `imageCount` | Photo URLs (with captions/categories when enriched) |
| `initialCostYen`, `coordinates` | Estimated move-in cost and `{ lat, lng }` map coordinates |
| `scrapedAt` | ISO timestamp |

**View:** the Output tab has a **Listings** table (listing ID, type, rent, price, mgmt fee, deposit, key money, layout, area, address, station, walk min, agency, phone, URL).

### Example Input

```json
{
  "listingType": "rent",
  "prefecture": "tokyo",
  "city": "shibuya-city",
  "maxListings": 100,
  "includeDetails": true,
  "proxy": { "useApifyProxy": false }
}
```

### Example Output

```json
{
  "listingId": "13329456",
  "url": "https://www.athome.co.jp/chintai/13329456/",
  "listingType": "rent",
  "propertyType": "apartment",
  "buildingName": "グランデュール渋谷",
  "rentYen": 177000,
  "rentText": "17.7万円",
  "managementFeeYen": 15000,
  "managementFeeText": "1.5万円",
  "deposit": "1ヶ月",
  "depositMonths": 1,
  "keyMoney": "1ヶ月",
  "keyMoneyMonths": 1,
  "layout": "1LDK",
  "areaM2": 26.26,
  "floor": "3階",
  "buildingAge": "築3年",
  "buildingAgeYears": 3,
  "address": "東京都渋谷区千駄ヶ谷３",
  "nearestStation": "代々木上原駅",
  "line": "小田急線",
  "walkMinutes": 7,
  "agentName": "グランデ新宿店",
  "agencyPhone": "03-5338-5960",
  "imageCount": 8,
  "initialCostYen": 531000,
  "coordinates": { "lat": 35.667, "lng": 139.711 },
  "scrapedAt": "2026-10-20T09:00:00.000Z"
}
```

### Automate Japan Property Monitoring With Schedules & Webhooks

- **Daily rent monitoring:** schedule `listingType: rent` for a ward and diff consecutive runs on `listingId` to catch new listings, rent cuts and what left the market.
- **Weekly price-per-m² tracking:** keep `includeDetails: false` for the cheapest sweep of whole prefectures, then enrich only the areas that moved.
- **Investor deal alerts:** webhook the dataset into Slack or a spreadsheet and filter sale listings by `priceYen` and `areaM2`.
- **Relocation feeds:** pipe a daily scheduled run into an expat-housing site or CRM; recurring runs also improve this actor's Store recommendation signals.

### Related Actors

- [SUUMO Scraper — Japan Property Data & API](https://apify.com/sian.agency/suumo-property-scraper) — the largest Japan-property actor in this cluster; covers rent and sale on SUUMO, Japan's #1 portal.
- [SUUMO Scraper — Japan Rental Listings & Agent Contacts](https://apify.com/jungle_synthesizer/suumo-scraper) — SUUMO rentals with listing-agency contact details.
- [SUUMO Japan Rentals Scraper](https://apify.com/youfuxu/suumo-japan-rentals-scraper) — lightweight SUUMO rental extraction.
- [at home Scraper — Japan Rental Property Data & API](https://apify.com/sian.agency/athome-property-scraper) — the other athome.co.jp actor; per-room rows with GPS and agency contacts.
- [Japan Rent Market Scraper — SUUMO + at home + LIFULL HOME'S](https://apify.com/fruitful_quintessence/japan-rent-market-scraper) — cross-portal rent comparison across Japan's three biggest portals.

### Frequently Asked Questions

#### Why use this actor instead of the official API?

AtHome (athome.co.jp) does not publish a public listings API. What the site does offer — the internal BFF endpoint and the embedded Angular SSR state — is exactly what this actor reads, over plain HTTP with no browser and no login. Third-party paid wrappers around AtHome listings exist (for example per-lookup credit APIs), but they are an added dependency and cost; this actor is the direct, pay-per-result route.

#### What are the alternatives to scraping AtHome?

1. **Other Japan property portals** — SUUMO (Japan's #1 portal, ~70,000+ rentals in Tokyo alone) and LIFULL HOME'S (#3) are the standard cross-checks, and several Apify actors cover them (see Related Actors).
2. **Third-party paid property APIs** that wrap AtHome/SUUMO listings, billed per lookup — convenient but priced per call.
3. **Agency direct feeds and licensed data** for institutional users.
4. **Scraping the public pages**, which is what this actor does at a fraction of a cent per listing.

#### Is there a free AtHome API?

No. There is no free and no documented public AtHome developer API. This actor reads the same embedded JSON the site's own frontend uses, and free Apify accounts get a 10-listing preview, paid accounts the full run up to `maxListings`.

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

Set `prefecture` to the roman prefecture slug and `city` to the AtHome city/ward slug — `shibuya-city`, `shinjuku-city`, `suginami-city`, `osaka-city-kita-ku` and so on. Leave `city` empty to sweep the whole prefecture.

#### Is the rent price normalised?

Yes. `rentYen`, `priceYen`, `managementFeeYen` and `initialCostYen` are integers in yen (the actor converts 万円 to yen for you), while `rentText`/`priceText`/`managementFeeText` keep the original string. Deposit and key money come as both `deposit`/`keyMoney` text and `depositMonths`/`keyMoneyMonths` counts.

#### Does it cover sale listings, not just rentals?

Yes — `listingType: sale-mansion` covers condominiums and `sale-house` covers detached houses. Sale records populate `priceYen`/`priceText` instead of rent, and are enriched from the detail page's SSR state.

#### Do I need a proxy?

Not for small runs. The embedded JSON and BFF endpoints answer plain HTTP requests; for large or high-frequency runs enable Apify Proxy (residential recommended) because the site can present a Geetest challenge to heavy datacenter traffic.

### For AI Agents & LLM Apps

**Purpose:** returns at home (athome.co.jp) rental and sale property listings for a Japanese prefecture (optionally a ward), one row per room/building, with yen-normalised prices, deposit/key money, layout, area, station access, agency contact, photos and coordinates.

**Minimal input:**

```json
{ "listingType": "rent", "prefecture": "tokyo", "maxListings": 20 }
```

**Cheap sweep variant (no detail requests):**

```json
{ "listingType": "rent", "prefecture": "osaka", "maxListings": 100, "includeDetails": false }
```

**Output fields:** listingId, url, listingType, propertyType, buildingType, title, buildingName, rentYen, rentText, priceYen, priceText, managementFeeYen, managementFeeText, deposit, depositMonths, keyMoney, keyMoneyMonths, layout, areaM2, floor, buildingAge, buildingAgeYears, address, ward, city, prefecture, nearestStation, line, walkMinutes, access, agentName, agencyPhone, agencyAddress, agencyUrl, photos, photoDetails, imageCount, initialCostYen, coordinates, scrapedAt.

**Behaviors an agent should know:**

- `listingType` and `prefecture` are **required**; `city` is optional and narrows to a ward.
- `maxListings` counts **rooms for rentals and buildings for sale**; pages are read lazily, so a cap of 100 usually needs one request.
- `includeDetails: true` adds one request and one billed `listing-detail` event **per listing**; set it `false` for the cheapest possible sweep (agency phone stays `null`).
- If a detail request fails, the list-page record is still pushed and the detail event is **not** charged.
- Free accounts get a 10-listing preview regardless of `maxListings`.

**Billing:** pay-per-event — `result` $0.0015 per listing, `listing-detail` $0.0005 per enriched listing, plus an Actor start event; free accounts get a 10-listing preview.

### Legal & Compliance Disclaimer

This actor is an independent tool and is not affiliated with, endorsed by, or sponsored by AtHome Co., Ltd. (athome.co.jp). It reads only publicly reachable pages and the site's own front-end JSON surfaces — no login, no account access, and no CAPTCHA solving. Business contact data published by listing agencies (agency name and phone) is returned as shown on the public listing and should not be used for unsolicited commercial outreach in violation of applicable law. Users are responsible for their own compliance with AtHome's Terms of Service, `robots.txt` and applicable data-protection law when storing, redistributing or automating access to the collected data.

### SEO Keywords

athome scraper, athome co jp scraper, japan real estate scraper, japan property data, tokyo rental listings, osaka property data, japan rent monitoring, suumo alternative, japan apartment data api, athome api alternative, japanese real estate data, japan rental market research, tokyo apartment prices, japan property database, japan real estate api, rental price monitoring japan, japan relocation data, ward level property data, japan property listings export, athome listings scraper, tokyo ward property data, japan proptech data, japan mansion prices, japanese property csv

# Actor input Schema

## `listingType` (type: `string`):

Rental listings (chintai), used/new condos (mansion) or used houses (kodate).

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

AtHome roman prefecture slug, e.g. tokyo, osaka, kanagawa, aichi, fukuoka, hokkaido.

## `city` (type: `string`):

Optional AtHome city slug to narrow the search, e.g. shibuya-city, shinjuku-city, suginami-city, osaka-city-kita-ku. Leave empty for the whole prefecture.

## `maxListings` (type: `integer`):

Hard cap on pushed listings (rooms for rent, buildings for sale). Result pages are fetched automatically until this many listings are collected.

## `includeDetails` (type: `boolean`):

Fetches the detail JSON for each listing to add agency phone, full photo list, exact address, coordinates and initial cost. Adds one request per listing and is billed per enriched listing (pay-per-event).

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "listingType": "rent",
  "prefecture": "tokyo",
  "city": "",
  "maxListings": 100,
  "includeDetails": true,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "prefecture": "tokyo",
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/athome-co-jp-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 = {
    "prefecture": "tokyo",
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/athome-co-jp-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 '{
  "prefecture": "tokyo",
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/athome-co-jp-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/athome-co-jp-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/ZPcHzeAZbpNTmHT37/builds/6KV5e12WvypbOnzJK/openapi.json