# Japan Municipal Akiya Bank Aggregator Scraper (`jungle_synthesizer/japan-akiya-bank-municipal-aggregator-scraper`) Actor

Akiya (vacant home) listings aggregated from municipal and prefectural akiya-bank portals across Japan — the long tail outside the large national aggregators. Covers Akita, Tottori, and Kochi prefectures: address, price or rent, building age/area, layout, photos, and the municipal contact point.

- **URL**: https://apify.com/jungle_synthesizer/japan-akiya-bank-municipal-aggregator-scraper.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Real estate, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 record scrapeds

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

## Japan Akiya Bank Municipal Aggregator Scraper

Scrape akiya (vacant home) listings from municipal and prefectural akiya-bank portals across
Japan. Returns address, price or rent, building age, building and land area, room layout,
photos, and the municipal contact point for each listing — aggregated across Akita, Tottori,
and Kochi prefectures in one run.

***

### Japan Akiya Bank Municipal Aggregator Scraper Features

- Pulls listings directly from municipal and prefectural akiya-bank sources — not a re-listing of a national real-estate site.
- Covers 3 prefectures today (Akita, Tottori, Kochi), each run independently so you can scope a crawl to one or all of them.
- Returns 20+ fields per listing: price or monthly rent, building age, building area, land area, room layout, structure, and photos.
- Filters by listing type (sale, rent, or free transfer) and by municipality name.
- Separates sale price from monthly rent even on listings that offer both — a surprisingly common shape in this data.
- Handles pagination automatically across all three sources, so one run covers a prefecture's full current inventory.

***

### Who Uses Akiya Bank Data?

- **Rural-revitalisation researchers** — track vacant-home inventory and pricing trends across depopulating municipalities.
- **Akiya-flip operators** — screen listings for renovation candidates by price, age, and floor area before contacting a municipality.
- **Relocation and JET-alumni networks** — surface cheap rural housing options outside the well-trodden national listing sites.
- **Property data aggregators** — feed municipal listings into a broader Japan real-estate dataset, including the long tail that larger national platforms don't carry.
- **Journalists and academics** — study the akiya (vacant home) problem with structured, per-listing data instead of PDF reports.

***

### How Japan Akiya Bank Municipal Aggregator Scraper Works

1. Pick one or more prefectures, or leave the field empty to crawl all three.
2. The scraper walks each prefecture's akiya-bank listings and visits every detail page, so you get the full field set per record, not just a search-result summary.
3. Each record is normalized into one consistent schema regardless of which prefecture it came from — same field names, same units, every time.
4. Optionally narrow the result set by municipality name or listing type (sale / rent / transfer) before the run finishes.

***

### Input

```json
{
  "prefectures": ["akita", "tottori", "kochi"],
  "municipalities": [],
  "listingTypes": [],
  "maxItems": 10
}
```

| Field            | Type    | Default                         | Description |
|------------------|---------|---------------------------------|--------------|
| `prefectures`    | array   | `["akita", "tottori", "kochi"]` | Prefectures to crawl. Leave empty for all 3 supported prefectures. |
| `municipalities` | array   | `[]`                            | Optional filter on municipality name (Japanese, e.g. `"横手市"`). Matches as a substring against each record's address. Leave empty for no filter. |
| `listingTypes`   | array   | `[]` (all)                      | Filter to one or more of `sale`, `rent`, `transfer`. Leave empty to return every type. |
| `maxItems`       | integer | `10`                            | Maximum number of listings to return. |
| `resumeCursor`   | string  | —                               | Cursor from a previous run's Output, to continue a crawl that stopped early. Leave empty for a fresh crawl. |

***

### Japan Akiya Bank Municipal Aggregator Scraper Output Fields

```json
{
  "listing_id": "akita-59",
  "municipality": "由利本荘市",
  "prefecture": "Akita",
  "listing_type": "sale",
  "title": "由利本荘市新田",
  "description": null,
  "address": "秋田県由利本荘市新田字板橋236-3",
  "latitude": 39.4276,
  "longitude": 140.2288,
  "building_age_years": 0,
  "building_area_sqm": 244.81,
  "land_area_sqm": 966.62,
  "structure": "木造",
  "floors": 2,
  "rooms_layout": "8DK 小屋裏物置",
  "price_jpy": 15600000,
  "rent_jpy": null,
  "photos": ["https://akiyabank-akita.com/images/DSCF0533_R.JPG"],
  "contact_municipality_url": "https://akiyabank-akita.com/contact",
  "source_url": "https://akiyabank-akita.com/bukken?id=59",
  "last_updated": "2026-08-31"
}
```

| Field                      | Type    | Description |
|----------------------------|---------|--------------|
| `listing_id`               | string  | Source-prefixed unique id (e.g. `akita-60`, `tottori-150`). |
| `municipality`             | string  | Municipality name, parsed from the listing's address. |
| `prefecture`               | string  | `Akita`, `Tottori`, or `Kochi`. |
| `listing_type`             | string  | `sale`, `rent`, or `transfer`. |
| `title`                    | string  | Listing title as given by the source. |
| `description`              | string  | Free-text notes. Not every source provides one — sparse by nature of the data. |
| `address`                  | string  | Full address as listed. |
| `latitude`                 | number  | Only populated where the source embeds a map pin. |
| `longitude`                | number  | Only populated where the source embeds a map pin. |
| `building_age_years`       | number  | Building age in years. |
| `building_area_sqm`        | number  | Building floor area in square meters. |
| `land_area_sqm`            | number  | Land area in square meters. |
| `structure`                | string  | Construction type (wood, RC, steel) where stated. |
| `floors`                   | integer | Floor count where stated. |
| `rooms_layout`             | string  | Room layout (e.g. `3LDK`, `4K`). |
| `price_jpy`                | number  | Sale price in JPY. |
| `rent_jpy`                 | number  | Monthly rent in JPY — populated for rental listings, including listings that offer both sale and rent. |
| `photos`                   | array   | Listing photo URLs. |
| `contact_municipality_url` | string  | Municipal contact page or form for this specific listing. |
| `source_url`               | string  | The listing's page on its source site. |
| `last_updated`             | string  | Last-updated date as stated by the source, where available. |

Some fields are sparse by nature of the underlying data rather than a scraping gap — not every
municipality publishes coordinates, a free-text description, or a structure type for every
listing. A price can also be genuinely absent: some listings are marked "price negotiable"
instead of carrying a figure.

***

### Resuming a large crawl

Every run emits a `resumeCursor` in its Output. If a large crawl stops before it finishes — because it hit `maxItems`, your spend cap (`maxTotalChargeUsd`), or was aborted — start a new run with **the same input** plus that `resumeCursor` to continue from where it left off. The crawl resumes from the queued work the previous run didn't reach.

- You are **not re-charged** for records the earlier run already delivered.
- Resume within your account's run-retention window — on the free tier, roughly your 10 most recent runs. Once the source run is pruned, its `resumeCursor` is no longer valid.
- `resumeCursor` is opaque — supply it unmodified.

***

### FAQ

#### How do I scrape Japan's akiya bank listings?

Run this actor with no input beyond the default, and it crawls all 3 supported prefectures (Akita, Tottori, Kochi). Narrow to one prefecture, a specific municipality, or a listing type using the input fields above.

#### What prefectures does this actor cover?

Akita, Tottori, and Kochi today. These are three of the five prefectures named in the original project plan — the other two don't yet have a live, verified akiya-bank source behind them, so they're left out rather than shipped as an option that silently returns nothing.

#### What data can I get from an akiya bank listing?

Address, price or monthly rent, building age, building and land area, room layout, construction type, photos, and the municipal office's own contact point for that listing — 22 fields in total, listed above.

#### Can I filter by municipality or listing type?

Yes. `municipalities` filters by municipality name (Japanese), and `listingTypes` narrows to one or more of sale, rent, or free transfer listings.

#### Do I need an account or API key for any of these sites?

No. Every supported source is a public municipal or prefectural listing page.

#### Why is `price_jpy` or `rent_jpy` sometimes empty?

Some listings are marked price-negotiable with no stated figure at all — that's a real property of the source data, not a parsing failure.

***

### Need More Features?

Need another prefecture, a different filter, or a field this actor doesn't return yet? [File an issue](https://console.apify.com/actors/issues) or get in touch.

### Why Use Japan Akiya Bank Municipal Aggregator Scraper?

- **Covers the long tail** — municipal and prefectural akiya banks that national real-estate aggregators don't carry.
- **One schema, three sources** — Akita, Tottori, and Kochi listings land in the same field layout, so you're not writing three different parsers to use this data.
- **Dual-price aware** — listings that offer both sale and rent come back with both figures correctly separated, not one number mislabeled as the other.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

What will this data feed? E.g. lead lists, KYB checks, price tracking.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

We'll personally help with your use case. No spam.

## `resumeCursor` (type: `string`):

Leave empty for a fresh crawl. To CONTINUE a previous run where it stopped — without paying again for records you already received — paste the `resumeCursor` value from that run's Output (the run's OUTPUT key). Resume promptly: the previous run's data expires with your account's retention window (free tier: your ~10 most recent runs).

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

Prefecture(s) to crawl. Empty = all supported prefectures. Tokushima and Yamaguchi (named in the original Phase 1 plan) are not yet live — see the README for why.

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

Optional free-text filter on municipality/address (Japanese name, e.g. "横手市"). Matches as a substring against each record's municipality and address fields. Empty = no filter.

## `listingTypes` (type: `array`):

Filter to one or more listing types. Empty = all types (sale, rent, and free transfer).

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

Maximum number of records to scrape.

## Actor input object example

```json
{
  "sp_contact": "Share your email here...",
  "prefectures": [
    "akita",
    "tottori",
    "kochi"
  ],
  "listingTypes": [],
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "sp_contact": "Share your email here...",
    "prefectures": [
        "akita",
        "tottori",
        "kochi"
    ],
    "listingTypes": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/japan-akiya-bank-municipal-aggregator-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 = {
    "sp_contact": "Share your email here...",
    "prefectures": [
        "akita",
        "tottori",
        "kochi",
    ],
    "listingTypes": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/japan-akiya-bank-municipal-aggregator-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 '{
  "sp_contact": "Share your email here...",
  "prefectures": [
    "akita",
    "tottori",
    "kochi"
  ],
  "listingTypes": [],
  "maxItems": 10
}' |
apify call jungle_synthesizer/japan-akiya-bank-municipal-aggregator-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jungle_synthesizer/japan-akiya-bank-municipal-aggregator-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/UkGecizcPMyZAGfe8/builds/89LO6VocT7B25WhgC/openapi.json