# AtHome Akiya Bank Scraper (Japan vacant houses) (`crowley/athome-akiya-bank-scraper`) Actor

Scrape every akiya (vacant house) bank listing from akiya-athome.jp across all 47 prefectures, with all detail fields. Fast HTTP crawler.

- **URL**: https://apify.com/crowley/athome-akiya-bank-scraper.md
- **Developed by:** [Crow Lee](https://apify.com/crowley) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## AtHome Akiya Bank Scraper — cheap & free houses across all 47 prefectures of Japan

Scrape every **akiya** (空き家 / vacant-house) bank listing from **akiya-athome.jp** — Japan's national directory of cheap and even **free (¥0) rural houses, land, and apartments** across all **47 prefectures**. No login, no API key. Filter by prefecture, deal type, property type, and price cap, then export clean JSON, CSV, or Excel with prices in **JPY (and optional live USD)**, land/building area, floor plan, build year, full image galleries, and ~50 normalized detail fields.

### 🏠 What does the AtHome Akiya Bank Scraper do?

This actor crawls the municipal akiya-bank listings published on `akiya-athome.jp` and turns them into structured records. You give it a few filters (which prefectures, sale/rent/gift, house/land/mansion, a max price in yen); it returns one row per property with price, location, size, floor plan, photos, and every spec from the listing's detail table.

It runs in two modes:

- **Summary mode** (`fetchDetails: false`) — fast pass over the listing cards. Title, price, type, prefecture, municipality, address, area, photo count.
- **Full-detail mode** (`fetchDetails: true`, default) — follows each listing into its detail page for the complete field set: ~50 English-normalized fields (`fields`), the raw Japanese fields (`fields_ja`), the full image gallery (`images` + captioned `imageDetails`), build year, structure, zoning, and more.

Output is available as **JSON, CSV, Excel (XLSX), XML, and HTML table** — downloadable from the dataset or via the Apify API, webhooks, and integrations.

### 👤 Who is the AtHome Akiya scraper for?

- **Foreign buyers hunting cheap rural Japan property** — sweep all 47 prefectures for sub-¥1M houses, or only the **gift / ¥0** listings, with prices shown in USD.
- **Akiya investors & renovation flippers** — pull land/building area, floor plan, structure, and build year to triage renovation candidates at scale.
- **Relocation seekers** — filter to your target prefecture and municipality, compare access/transport and price in one spreadsheet.
- **Real-estate data & content teams** — build a fresh akiya dataset for newsletters, maps, dashboards, or market analysis.
- **Agents & researchers** — feed normalized rows into your own models, CRMs, or AI agents (MCP-ready).

### ⭐ Why use this akiya scraper?

- **All 47 prefectures** — filter by 2-digit JIS code (`13`), English name (`Tokyo`), or Japanese name (`東京都`). Leave it empty to scrape every prefecture (~11,000 listings).
- **Find the free houses** — `transactionType: "gift"` keeps only ¥0 properties. Every record also carries an `isGift` flag, which is `true` only for a ¥0 **sale** (a house genuinely given away) — a ¥0 **rental** is a zero-rent lease, not a free house, so it is never flagged `isGift`.
- **Price per m² for investors** — every record carries `pricePerSqm_jpy`, the listing price divided by the building floor area (rounded yen), so you can rank renovation candidates by value at a glance.
- **Price cap in yen** — set `maxPriceJpy` to filter at the source (e.g. only properties under ¥1,000,000).
- **JPY → USD conversion** — turn on `convertUsd` and the actor fetches the day's ECB reference rate (via frankfurter.app) and fills `price_usd` on every listing.
- **Property-type filter** — house (戸建), land (土地), mansion (マンション), investment (投資), or business (事業).
- **Skip the tear-downs** — `excludeTeardown` hides properties marked for demolition (要取壊し / 古家あり / 解体).
- **Nothing lost in translation** — ~50 fields normalized to English keys, plus the raw Japanese field table kept verbatim.
- **No login, no API key** — clean structured data straight to a dataset.

### 📊 What data can you extract from akiya-athome.jp?

Every listing record includes (full-detail mode):

| Data point | Example |
| --- | --- |
| **price_jpy** | `2500000` |
| **price_usd** (optional) | `16100` |
| pricePerSqm_jpy | `22325` |
| isGift | `false` |
| url | `https://okutama-t13308.akiya-athome.jp/bukken/detail/buy/46555` |
| listingId | `"46555"` |
| propertyNumber | `"125"` |
| title | `東京都西多摩郡奥多摩町河内 378番5` |
| transactionType | `"sale"` (sale / rent) |
| propertyType | `"house"` (house / land / mansion / invest / business) |
| categoryLabel (JA) | `売戸建` |
| prefecture_code / _en / _ja | `13` / `Tokyo` / `東京都` |
| municipality | `西多摩郡奥多摩町` |
| address | `東京都西多摩郡奥多摩町河内 378番5` |
| access | `南海電鉄南海本線 高石駅/徒歩8分` |
| landArea_m2 | `290.9` |
| buildingArea_m2 | `111.98` |
| floorPlan | `4DK` |
| buildYearMonth | `不詳` |
| photoCount | `10` |
| images | `[ "https://img.akiya-athome.jp/?v=…", … ]` |
| imageDetails | `[ { url, thumbnail, caption: "外観" }, … ]` |
| fields | `{ structure: "木造", zoning, parking, … }` (~50 EN keys) |
| fields_ja | `{ "建物構造": "木造", "用途地域": "…", … }` (raw) |
| akiyaBankUrl | `https://okutama-t13308.akiya-athome.jp` |
| scrapedAt | `2026-06-16T16:37:42.741Z` |

> **Note:** `price_usd` is only populated when `convertUsd` is on (default). `pricePerSqm_jpy` is `round(price_jpy / buildingArea_m2)` when both a price and a building area are present, otherwise `null` (e.g. land parcels). `isGift` is `true` only for a ¥0 **sale** — a ¥0 rental is not a gift. `fields`, `fields_ja`, `images`, and `imageDetails` are only populated in full-detail mode (`fetchDetails: true`). Some fields come back as `"-"` or `不詳` ("unknown") when the municipality didn't publish them — that is the source data, preserved as-is.

The `fields` object normalizes the listing's detail table to English keys, including: `price`, `floorPlan`, `access`, `address`, `buildYearMonth`, `buildingArea`, `landArea`, `propertyCategory`, `structure`, `parking`, `landRights`, `cityPlanning`, `zoning`, `roadAccess`, `buildingCoverageRatio`, `floorAreaRatio`, `landCategory`, `topography`, `setback`, `currentStatus`, `handover`, `brokerageFee`, `facilities`, `features`, `remarks`, `companyName`, `licenseNumber`, `transactionMode`, and more.

### 💰 How much does it cost to scrape akiya-athome.jp?

This actor uses **pay-per-event** pricing:

| Event | Price (USD) |
| --- | --- |
| Actor start (once per run) | **$0.04** |
| Per listing scraped (`result`) | **$0.001** |

That's **$1.00 per 1,000 listings** plus the $0.04 start fee. In-run duplicates are not billed — the same property often appears under both the buy and rent paths, and the actor dedupes before charging.

#### Real-world cost examples

Based on real test runs (full-detail mode):

| Run | Listings | Event cost | + start | **Total** |
| --- | --- | --- | --- | --- |
| Tokyo sample (full detail) | 15 | $0.015 | $0.04 | **~$0.055** |
| Osaka sample (gift + paid) | 18 | $0.018 | $0.04 | **~$0.058** |
| 4-prefecture sample | 108 | $0.108 | $0.04 | **~$0.148** |
| 1,000 listings | 1,000 | $1.00 | $0.04 | **~$1.04** |
| Full Japan (all 47) | ~11,000 | $11.00 | $0.04 | **~$11.04** |

With the Apify Free plan's **$5 of monthly platform credit**, you can scrape roughly **~4,900 listings/month** at no extra cost. (Proxy traffic is billed separately by Apify per your plan.)

### 🚀 How to scrape akiya listings (step by step)

1. Open the **AtHome Akiya Bank Scraper** on Apify and click **Try for free**.
2. In **Prefectures**, add one or more JIS codes / English names / Japanese names — or leave it empty for all 47.
3. Pick a **Transaction type** (Any / Sale / Rent / **Gift = free ¥0**) and a **Property type**.
4. Optionally set **Max price (JPY)**, toggle **Exclude teardown**, **Add USD price**, and **Fetch detail pages**.
5. Set **Max items** (default 50; `0` = unlimited).
6. Click **Start**, watch the run, then **Export** the dataset as JSON, CSV, or Excel.

### 🧩 Input examples

**Minimal — 50 listings in Tokyo:**

```json
{
  "prefectures": ["Tokyo"],
  "maxItems": 50
}
````

**Only free (¥0) houses, nationwide, in USD:**

```json
{
  "prefectures": [],
  "transactionType": "gift",
  "propertyType": "house",
  "excludeTeardown": true,
  "convertUsd": true,
  "fetchDetails": true,
  "maxItems": 0
}
```

**Cheap rural houses under ¥1,000,000 in three regions (mixed code / EN / JA):**

```json
{
  "prefectures": ["01", "Nagano", "大阪府"],
  "transactionType": "sale",
  "propertyType": "house",
  "maxPriceJpy": 1000000,
  "maxItems": 500
}
```

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `prefectures` | array | `[]` (all 47) | JIS codes (`"01"`–`"47"`), English (`"Tokyo"`), or Japanese (`"東京都"`) names. |
| `transactionType` | string | `"any"` | `any` (sale + rent), `sale`, `rent`, or `gift` (only ¥0 / free). |
| `propertyType` | string | `"any"` | `any`, `house`, `land`, `mansion`, `invest`, `business`. |
| `maxPriceJpy` | integer | — | Max price in yen. Empty = no ceiling. |
| `excludeTeardown` | boolean | `false` | Hide properties flagged for demolition (要取壊し / 古家あり / 解体). |
| `fetchDetails` | boolean | `true` | Follow each listing into its detail page for the full field set. Off = faster summary run. |
| `convertUsd` | boolean | `true` | Fetch the day's ECB reference JPY/USD rate (via frankfurter.app) at start and populate `price_usd`. Daily reference rate, not a real-time market quote. |
| `maxItems` | integer | `50` | Max listings to scrape. `0` = unlimited (~11,000 total). |
| `maxConcurrency` | integer | `10` | Max parallel requests (1–50). Lower it if you hit blocking. |
| `proxyConfiguration` | object | Apify Proxy (RESIDENTIAL) | Proxy settings. RESIDENTIAL is most reliable; DATACENTER is cheaper — try it on a small run and switch back if you see failures. |

### 📤 Output example

A real listing record (full-detail mode, abbreviated for length):

```json
{
  "url": "https://okutama-t13308.akiya-athome.jp/bukken/detail/buy/46555",
  "listingId": "46555",
  "propertyNumber": "125",
  "title": "東京都西多摩郡奥多摩町河内 378番5",
  "transactionType": "sale",
  "propertyType": "house",
  "categoryLabel": "売戸建",
  "price_jpy": 2500000,
  "price_usd": 16100,
  "pricePerSqm_jpy": 22325,
  "priceText": "250万円",
  "isGift": false,
  "prefecture_code": "13",
  "prefecture_en": "Tokyo",
  "prefecture_ja": "東京都",
  "municipality": "西多摩郡奥多摩町",
  "municipalitySlug": "okutama-t13308",
  "address": "東京都西多摩郡奥多摩町河内 378番5",
  "access": "-",
  "landArea_m2": 290.9,
  "buildingArea_m2": 111.98,
  "floorPlan": "4DK",
  "buildYearMonth": "不詳",
  "photoCount": 10,
  "images": [
    "https://img.akiya-athome.jp/?v=4An4GIf0vfAdf0JiNuBp_3H7gXQj3AiIDMkhbbGoks3v…"
  ],
  "imageDetails": [
    { "url": "https://img.akiya-athome.jp/?v=4An4GIf0…", "thumbnail": "https://img.akiya-athome.jp/?v=KcX4Ywl…", "caption": "外観" },
    { "url": "https://img.akiya-athome.jp/?v=KcX4Ywl…", "thumbnail": "https://img.akiya-athome.jp/?v=YzeWPz6…", "caption": "間取図(平面図)" }
  ],
  "akiyaBankUrl": "https://okutama-t13308.akiya-athome.jp",
  "fields": {
    "price": "250万円",
    "floorPlan": "4DK",
    "buildingArea": "111.98㎡",
    "landArea": "290.90㎡",
    "structure": "木造",
    "facilities": "電気 ・上水道 ・下水道 ・プロパンガス",
    "features": "駐車場2台以上 南向 閑静な住宅街 都市ガス システムキッチン 二世帯向 角地",
    "propertyCategory": "売戸建"
  },
  "fields_ja": {
    "価格": "250万円",
    "間取り": "4DK",
    "建物面積": "111.98㎡",
    "土地面積": "290.90㎡",
    "建物構造": "木造"
  },
  "scrapedAt": "2026-06-16T16:37:42.741Z"
}
```

**A free (¥0 / gift) listing** is a ¥0 **sale** — note `price_jpy: 0`, `transactionType: "sale"`, and `isGift: true`:

```json
{
  "url": "https://example-c01234.akiya-athome.jp/bukken/detail/buy/12345",
  "listingId": "12345",
  "transactionType": "sale",
  "propertyType": "house",
  "categoryLabel": "売戸建",
  "price_jpy": 0,
  "isGift": true,
  "prefecture_en": "Hokkaido",
  "floorPlan": "3DK",
  "photoCount": 8
}
```

> **¥0 rentals are not gifts.** A listing under the `rent` path with `price_jpy: 0` is a zero-rent lease (the municipality publishes ¥0 in the price slot), not a free house. The actor flags those `isGift: false` so a buyer searching for genuinely free houses isn't misled.

### 💡 Tips for best results

- **Start small.** Run with `maxItems: 25` and one prefecture to preview the data shape before a full crawl.
- **Free houses fast:** set `transactionType: "gift"` + `prefectures: []` to sweep every ¥0 property in Japan in one run.
- **Need it quick?** Turn off `fetchDetails` for a summary-only pass — it skips the per-listing detail fetch.
- **Getting blocked?** Keep the RESIDENTIAL proxy (default) and lower `maxConcurrency`. The run fails loudly with a clear message if the proxy is blocked and 0 listings come back.
- **Schedule it** (Apify Schedules) to re-crawl your target prefectures daily/weekly and catch new akiya as they're listed.

### 🩺 Run health & failed requests

The actor tracks requests that failed after all retries and saves the full list to the key-value store under `FAILED_REQUESTS`. It also pushes an **error record** to the dataset for each permanently failed request — `{ "error": true, "errorDescription": "...", "url": "...", "scrapedAt": "..." }` — so consumers see failures inline alongside the listings (these error rows are not billed). If **every** request fails (0 listings scraped), the run is marked failed with a clear message — almost always a sign the proxy was blocked. Switch to a RESIDENTIAL Apify proxy and retry.

### 🔗 Integrations

Push your akiya data anywhere with Apify's built-in integrations:

- **Google Sheets** — sync listings to a live spreadsheet.
- **Slack / Discord** — get notified when new free houses appear.
- **Make / Zapier** — pipe results into 1,000+ apps.
- **BigQuery / Snowflake** — load into your data warehouse.
- **Webhooks** — trigger your own services on run finish.
- **Schedules** — automate recurring crawls.

### 🤖 API usage

Run the actor programmatically with the Apify API. Replace `<YOUR_TOKEN>` with your API token.

**Node.js (apify-client):**

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

const client = new ApifyClient({ token: '<YOUR_TOKEN>' });

const run = await client.actor('crowley~athome-akiya-bank-scraper').call({
    prefectures: ['Tokyo', 'Nagano'],
    transactionType: 'sale',
    propertyType: 'house',
    maxPriceJpy: 1000000,
    convertUsd: true,
    maxItems: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python (apify-client):**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_TOKEN>")

run = client.actor("crowley~athome-akiya-bank-scraper").call(run_input={
    "prefectures": ["Tokyo", "Nagano"],
    "transactionType": "gift",
    "convertUsd": True,
    "maxItems": 200,
})

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

**cURL:**

```bash
curl -X POST "https://api.apify.com/v2/acts/crowley~athome-akiya-bank-scraper/runs?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "prefectures": ["Tokyo"],
    "transactionType": "gift",
    "maxItems": 100
  }'
```

### 🧠 Use with AI agents via MCP

This actor is callable from AI agents through the **Apify MCP server**, so Claude, Cursor, and other MCP clients can run it as a tool.

Add it to a Claude Desktop / Claude Code / Cursor MCP config:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "crowley/athome-akiya-bank-scraper"],
      "env": { "APIFY_TOKEN": "<YOUR_TOKEN>" }
    }
  }
}
```

Example prompts:

- "Find every free akiya house in Japan under the gift program and list them with USD prices."
- "Scrape houses in Nagano under ¥1,000,000, excluding tear-downs, and summarize land vs building area."
- "Get the 50 cheapest sale listings in Hokkaido with their floor plans and photo counts."

### ❓ FAQ

**Is scraping akiya-athome.jp legal?**
This actor collects only publicly available listing data — no login, no personal accounts. As with any scraping, use the data responsibly and in line with applicable laws. See [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

**Do I need an account or API key for the site?**
No. The actor reads public listing pages — no akiya-athome.jp login required.

**Can I really find free houses?**
Yes. Set `transactionType: "gift"` to keep only ¥0 listings. Every record also has an `isGift` boolean. `isGift` is `true` only for a ¥0 **sale** — a genuinely free house. A ¥0 **rental** (a zero-rent lease) is *not* flagged `isGift`, so you won't confuse the two. (A ¥0 price is the headline figure; transfer, renovation, and registration costs are set by each municipality.)

**How do I get prices in US dollars?**
Leave `convertUsd` on (default). At the start of the run the actor fetches the day's ECB reference JPY/USD rate (via frankfurter.app) and fills `price_usd` on every listing. This is the daily reference rate, not a real-time market quote, so all listings in one run share a single rate.

**How many listings are there in total?**
Roughly 11,000 across all 47 prefectures. Set `maxItems: 0` to scrape everything.

**Why are some fields `"-"` or `不詳`?**
Each municipality publishes its own listings, so coverage varies. The actor preserves the source values exactly (`不詳` = "unknown"); nothing is invented.

**Which proxy should I use?**
RESIDENTIAL (the default) is most reliable for this site. DATACENTER is cheaper — try it on a small run and switch back if you see many failed requests.

**What output formats can I export?**
JSON, CSV, Excel (XLSX), XML, and HTML table — from the dataset UI or via the Apify API, webhooks, and integrations.

### ⚖️ Legality

This scraper extracts **publicly available** real-estate listing data only and does not collect private or personal information behind a login. Listings on akiya-athome.jp are published by Japanese municipalities for public access. When your dataset includes any personal data (for example an agent's name or contact), handle it in compliance with applicable privacy laws such as the **GDPR** (if you process EU residents' data) and Japan's **APPI** (Act on the Protection of Personal Information). Read Apify's guide: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

### 🗣️ Your feedback

Found a bug or want a new feature? Open an issue on the actor's **Issues** tab (actor ID `14YVip0CJqF01oluM`). We actively maintain this scraper and read every report.

### 🧭 More scrapers by this author

- [Galaxus / Digitec Scraper](https://apify.com/crowley/galaxus-digitec-scraper) — Swiss e-commerce products & prices.
- [Anibis.ch Scraper](https://apify.com/crowley/anibis-ch-scraper) — Swiss classifieds listings.
- [Ricardo.ch Scraper](https://apify.com/crowley/ricardo-ch-scraper) — Swiss auction & marketplace listings.
- [Comparis.ch Scraper](https://apify.com/crowley/comparis-ch-scraper) — Swiss real estate, insurance & price comparison.
- [AutoScout24.ch Scraper](https://apify.com/crowley/autoscout24-ch-scraper) — Swiss used-car listings.
- [Local.ch Scraper](https://apify.com/crowley/local-ch-scraper) — Swiss business directory.

### 📝 Changelog

#### 2026-06-17

- Added `pricePerSqm_jpy` — listing price per m² of building floor area (rounded yen), for investor triage.
- Refined `isGift`: now `true` only for a ¥0 **sale** (a genuinely free house). ¥0 **rentals** (zero-rent leases) are no longer mislabelled as gifts.
- Permanently failed requests are now also pushed to the dataset as inline error records (`{ error, errorDescription, url }`), in addition to the `FAILED_REQUESTS` key-value store entry.
- Clarified that `convertUsd` uses the day's ECB reference rate (via frankfurter.app), not a real-time market quote.

#### 2026-06-16

- Initial public release.
- All 47 prefectures (filter by JIS code / English / Japanese name).
- Transaction type filter incl. **gift / free (¥0)** mode; `isGift` flag on every record.
- Property-type filter (house / land / mansion / investment / business).
- Max price (JPY) cap and tear-down exclusion.
- Optional live JPY → USD conversion (`price_usd`).
- Summary vs full-detail modes with ~50 normalized fields, raw Japanese fields, and full image galleries.
- Pay-per-event pricing with in-run deduplication.

# Actor input Schema

## `prefectures` (type: `array`):

Prefectures to scrape. Use 2-digit JIS codes ('01'-'47'), English names ('Hokkaido', 'Tokyo'), or Japanese names ('北海道', '東京都'). Leave empty to scrape all 47 prefectures.

## `transactionType` (type: `string`):

Filter by deal type. 'gift' keeps only ¥0 (free) properties.

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

Filter by property category.

## `maxPriceJpy` (type: `integer`):

Maximum price in yen. Empty = no ceiling.

## `excludeTeardown` (type: `boolean`):

Hide properties marked as requiring demolition (要取壊し / 古家あり and teardown notes).

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

Follow each listing into its detail page for the full ~40 fields. Disable for a faster, summary-only run.

## `convertUsd` (type: `boolean`):

At run start, fetch the day's ECB reference JPY/USD rate (via frankfurter.app) and populate price\_usd. This is the daily reference rate, not a real-time market quote.

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

Maximum number of listings to scrape. 0 = unlimited (~11,000 total).

## `maxConcurrency` (type: `integer`):

Maximum parallel requests. Lower this if you hit blocking.

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

Proxy configuration. RESIDENTIAL is the default and most reliable. DATACENTER is cheaper and may work — try it on a small run; if you see many failed requests, switch back to RESIDENTIAL.

## Actor input object example

```json
{
  "prefectures": [
    "13",
    "Osaka",
    "北海道"
  ],
  "transactionType": "any",
  "propertyType": "any",
  "excludeTeardown": false,
  "fetchDetails": true,
  "convertUsd": true,
  "maxItems": 50,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Vacant-house listings scraped from akiya-athome.jp

# 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 = {
    "prefectures": [
        "Tokyo"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("crowley/athome-akiya-bank-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 = { "prefectures": ["Tokyo"] }

# Run the Actor and wait for it to finish
run = client.actor("crowley/athome-akiya-bank-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 '{
  "prefectures": [
    "Tokyo"
  ]
}' |
apify call crowley/athome-akiya-bank-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crowley/athome-akiya-bank-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AtHome Akiya Bank Scraper (Japan vacant houses)",
        "description": "Scrape every akiya (vacant house) bank listing from akiya-athome.jp across all 47 prefectures, with all detail fields. Fast HTTP crawler.",
        "version": "1.0",
        "x-build-id": "wm5a5csC1FfyQbzXL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crowley~athome-akiya-bank-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crowley-athome-akiya-bank-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/crowley~athome-akiya-bank-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crowley-athome-akiya-bank-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/crowley~athome-akiya-bank-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crowley-athome-akiya-bank-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": {
                    "prefectures": {
                        "title": "Prefectures",
                        "type": "array",
                        "description": "Prefectures to scrape. Use 2-digit JIS codes ('01'-'47'), English names ('Hokkaido', 'Tokyo'), or Japanese names ('北海道', '東京都'). Leave empty to scrape all 47 prefectures.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "transactionType": {
                        "title": "Transaction type",
                        "enum": [
                            "any",
                            "sale",
                            "rent",
                            "gift"
                        ],
                        "type": "string",
                        "description": "Filter by deal type. 'gift' keeps only ¥0 (free) properties.",
                        "default": "any"
                    },
                    "propertyType": {
                        "title": "Property type",
                        "enum": [
                            "any",
                            "house",
                            "land",
                            "mansion",
                            "invest",
                            "business"
                        ],
                        "type": "string",
                        "description": "Filter by property category.",
                        "default": "any"
                    },
                    "maxPriceJpy": {
                        "title": "Max price (JPY)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price in yen. Empty = no ceiling."
                    },
                    "excludeTeardown": {
                        "title": "Exclude teardown properties",
                        "type": "boolean",
                        "description": "Hide properties marked as requiring demolition (要取壊し / 古家あり and teardown notes).",
                        "default": false
                    },
                    "fetchDetails": {
                        "title": "Fetch detail pages",
                        "type": "boolean",
                        "description": "Follow each listing into its detail page for the full ~40 fields. Disable for a faster, summary-only run.",
                        "default": true
                    },
                    "convertUsd": {
                        "title": "Add USD price",
                        "type": "boolean",
                        "description": "At run start, fetch the day's ECB reference JPY/USD rate (via frankfurter.app) and populate price_usd. This is the daily reference rate, not a real-time market quote.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape. 0 = unlimited (~11,000 total).",
                        "default": 50
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum parallel requests. Lower this if you hit blocking.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy configuration. RESIDENTIAL is the default and most reliable. DATACENTER is cheaper and may work — try it on a small run; if you see many failed requests, switch back to RESIDENTIAL.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```