# Suumo Japan Property Listings Scraper (`automation-lab/suumo-japan-property-listings-scraper`) Actor

Export public SUUMO Japan rental and used-condo listings with stable IDs, prices, fees, layouts, areas, locations, station access, images, and canonical URLs.

- **URL**: https://apify.com/automation-lab/suumo-japan-property-listings-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.44 / 1,000 item extracteds

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?

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

## How to integrate an Actor?

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

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

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

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

# README

## SUUMO Japan Property Listings Scraper

Export **SUUMO Japan property listings** as clean rental and used-condominium records.
Give the Actor the public search URLs produced by SUUMO's Japanese location and property filters.
It follows result pages and returns stable listing IDs, normalized yen prices, fees, layouts, floor areas, addresses, station access, images, and canonical listing URLs.

The default dataset is designed for recurring inventory snapshots, market research, spreadsheet exports, and data pipelines.
No SUUMO account is required.

### What does this Actor do?

The Actor turns two public SUUMO search result formats into one consistent dataset:

- rental searches under `suumo.jp/chintai/`;
- used-condominium sale searches under `suumo.jp/ms/chuko/`.

Each rental unit becomes one row, even when several units appear under the same building.
Each used-condo result becomes one row.
Prices are preserved in their displayed context and normalized to integer Japanese yen.

Use a SUUMO search URL to retain the location and criteria you selected on the source site.
The Actor then follows the visible next-page link until it reaches your item or page limit.

### Who is it for?

This Actor is useful for:

- real-estate analysts comparing asking rents or sale prices;
- property managers tracking competing inventory;
- relocation teams collecting current area options;
- investors reviewing used-condo asking prices;
- researchers building repeatable Japanese housing snapshots;
- data engineers loading SUUMO records into a warehouse or BI tool;
- operators comparing new, removed, and repriced listings between scheduled runs.

It is a data extractor, not a valuation model.
It does not calculate yields, predict prices, or determine whether a property is available beyond what the result page currently displays.

### Why use it?

- **Stable identity:** `listingId` and `buildingId` support repeat-run comparisons.
- **Unified records:** rent and sale results share one documented schema.
- **Normalized prices:** Japanese `万円` values become integer yen.
- **Search provenance:** every row retains the original `searchUrl` and result page.
- **Useful media:** result-card image URLs and badges are included.
- **Bounded execution:** `maxItems` and `maxPagesPerUrl` keep runs predictable.
- **Clear failures:** blocked or unrecognized pages fail instead of returning a misleading empty success.
- **Low overhead:** direct HTTP and HTML parsing avoid downloading image bodies or launching a browser.

### Supported SUUMO searches

Supported inputs are public HTTPS result URLs on `suumo.jp` for:

1. rental property searches, for example `https://suumo.jp/chintai/tokyo/sc_shinjuku/`;
2. used-condominium sale searches, for example `https://suumo.jp/ms/chuko/tokyo/sc_shinjuku/`.

Choose city, ward, station, layout, price, walking distance, area, age, and other available criteria on SUUMO before copying the resulting URL.
The Actor preserves those URL parameters.

Other SUUMO verticals, individual detail URLs, saved searches requiring an account, and agency contact extraction are not supported in this version.

### Data you can extract

| Field | Meaning |
| --- | --- |
| `listingId` | Stable SUUMO listing or rentable-unit ID |
| `buildingId` | Building/property identifier when exposed |
| `listingType` | `rent` or `sale` |
| `propertyType` | Displayed Japanese property category |
| `title` | Property or building name |
| `priceYen` | Normalized monthly rent or sale price in JPY |
| `rentYen` | Monthly rent in JPY for rentals |
| `managementFeeYen` | Monthly management fee in JPY when shown |
| `deposit` | Deposit text as displayed |
| `keyMoney` | Key-money text as displayed |
| `layout` | Layout such as `1DK` or `2LDK` |
| `floorAreaSqm` | Floor area in square metres |
| `floor` | Unit floor when shown |
| `address` | Japanese location displayed in results |
| `stationAccess` | Rail line, station, and walking-access entries |
| `buildingAge` | Displayed age or construction month |
| `buildingFloors` | Building floor count when exposed |
| `images` | Public result-card image URLs |
| `tags` | New-listing and media badges |
| `canonicalUrl` | Absolute SUUMO detail URL |
| `searchUrl` | Original search/filter context |
| `page` | Result page processed by this run |
| `scrapedAt` | UTC extraction timestamp |

Fields remain present with `null` or an empty array when SUUMO does not expose a value in that result format.

### Getting started

1. Open SUUMO and configure a rental or used-condo search.
2. Copy the search result URL from your browser.
3. Add it to **SUUMO search URLs**.
4. Keep `maxItems` small for a first run.
5. Click **Start**.
6. Open the run's **Storage** tab and select the default dataset.
7. Export JSON, CSV, Excel, XML, or RSS from Apify.

A useful first input is:

```json
{
  "startUrls": [
    { "url": "https://suumo.jp/chintai/tokyo/sc_shinjuku/" }
  ],
  "maxItems": 25,
  "maxPagesPerUrl": 1,
  "listingTypes": ["rent"]
}
```

### Input parameters

#### `startUrls`

Required array of 1–20 public SUUMO search URLs.
Strings and Apify request-list objects are accepted by the runtime.
Only HTTPS URLs whose hostname is `suumo.jp` or a subdomain are accepted.

#### `maxItems`

Maximum unique rows saved across all inputs.
Default: `100`.
Range: 1–10,000.
The Actor stops accepting records as soon as the limit is reached.

#### `maxPagesPerUrl`

Maximum visible result pages followed for each URL.
Default: `3`.
Range: 1–100.
Use this with `maxItems` to define a bounded snapshot.

#### `listingTypes`

Optional array containing `rent`, `sale`, or both.
It filters normalized output; it does not convert a rental URL into a sale search.

#### `minPriceYen` and `maxPriceYen`

Optional inclusive filters in integer Japanese yen.
For rentals, they apply to monthly rent.
For used condos, they apply to the displayed sale price.
Rows without a normalized price do not pass an enabled price filter.

### Output example

A rental row has this shape:

```json
{
  "listingId": "100500000001",
  "buildingId": "000100000001",
  "listingType": "rent",
  "propertyType": "賃貸マンション",
  "title": "サンプルレジデンス",
  "priceYen": 128000,
  "rentYen": 128000,
  "managementFeeYen": 8000,
  "deposit": "12.8万円",
  "keyMoney": "12.8万円",
  "layout": "1LDK",
  "floorAreaSqm": 42.5,
  "floor": "3階",
  "address": "東京都新宿区西新宿１",
  "stationAccess": ["JR山手線/新宿駅 歩8分"],
  "buildingAge": "築8年",
  "buildingFloors": "12階建",
  "images": ["https://img01.suumo.com/sample/property.jpg"],
  "tags": ["新着"],
  "canonicalUrl": "https://suumo.jp/chintai/jnc_000100000001/",
  "searchUrl": "https://suumo.jp/chintai/tokyo/sc_shinjuku/",
  "page": 1,
  "scrapedAt": "2026-01-15T12:00:00.000Z"
}
```

The example values are anonymized, but the field shape matches current runtime output.

### How much does it cost to export SUUMO property listings?

The Actor uses pay-per-event pricing:

- **Actor start:** $0.005 once per run.
- **Property listing:** tiered by your Apify plan; BRONZE is currently $0.0024 per saved row.

At the current BRONZE rate:

| Saved listings | Estimated Actor charge |
| ---: | ---: |
| 25 | $0.065 |
| 100 | $0.245 |
| 1,000 | $2.405 |

These examples include one start event and exclude your normal Apify platform usage.
Only unique rows that pass filters and are saved produce the property-listing event.
Failed requests, duplicates, and rejected rows are not item events.
Check the live pricing panel because plan tiers can differ.

### Recurring inventory monitoring

Schedule the same Actor input daily or weekly with an Apify Task.
Export or integrate the default dataset after each run.
Then compare rows by `listingId`:

- ID present only in the newest snapshot: potentially new listing;
- ID missing from the newest snapshot: potentially removed inventory;
- same ID with changed `priceYen`: displayed asking-price change;
- same ID with changed fees or tags: listing-card update.

The Actor emits snapshots.
It does not keep history or label changes itself, so store prior datasets in your own database, spreadsheet, or automation flow.

### Spreadsheet and BI workflow

Download the dataset as CSV or Excel from the Storage tab.
Use `listingId` as the primary comparison key.
Use `searchUrl` to separate areas or property criteria.
Keep `scrapedAt` as the snapshot timestamp.

For dashboards, normalize `stationAccess` and `images` arrays in your destination if your BI tool expects one value per row.

### API usage with cURL

Start a synchronous run and return dataset items:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~suumo-japan-property-listings-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://suumo.jp/chintai/tokyo/sc_shinjuku/"}],
    "maxItems": 25,
    "maxPagesPerUrl": 1
  }'
```

Keep API tokens in secrets or environment variables rather than source code.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/suumo-japan-property-listings-scraper').call({
  startUrls: [{ url: 'https://suumo.jp/ms/chuko/tokyo/sc_shinjuku/' }],
  listingTypes: ['sale'],
  maxItems: 20,
  maxPagesPerUrl: 1,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/suumo-japan-property-listings-scraper').call(run_input={
    'startUrls': [{'url': 'https://suumo.jp/chintai/tokyo/sc_shinjuku/'}],
    'maxItems': 25,
    'maxPagesPerUrl': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/suumo-japan-property-listings-scraper"
```

#### Claude Desktop setup

Add the following remote MCP server in Claude Desktop's connector settings.

#### Cursor setup

Add the same server object to Cursor's MCP configuration.

#### VS Code setup

Add the same remote endpoint through your VS Code MCP extension or workspace MCP settings.

All three clients can use this JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/suumo-japan-property-listings-scraper"
    }
  }
}
```

Example prompts:

- “Export 25 current Shinjuku rental listings from SUUMO.”
- “Collect the first page of Shinjuku used-condo prices and floor areas.”
- “Run my saved SUUMO search URLs and return IDs and prices for an inventory comparison.”

### Reliability and retry behavior

SUUMO can occasionally return a temporary 503, 429, or network error.
The Actor retries transient failures up to four times with bounded delays.
It validates that the response contains a recognized rental or used-condo result structure.
If every attempt fails, the run fails with the affected URL rather than emitting a false empty dataset.

No residential proxy or browser fallback runs automatically.
That keeps transfer and compute predictable, but it means sustained source blocking can require a later implementation update.

### Limits and responsible scaling

- Keep page and item limits no larger than your actual analysis requires.
- Avoid launching many overlapping runs for the same search.
- Result order and inventory can change while a multi-page run is active.
- Several rental units may share a building title and address but have different `listingId` values.
- Search-card images may be resized variants and are not downloaded by the Actor.
- Japanese labels are preserved where translation could alter source meaning.
- Detail-only fields, agency contacts, descriptions, amenities, and complete photo galleries are outside the current scope.

### Troubleshooting

#### The run says the URL is unsupported

Confirm it uses HTTPS and belongs to `suumo.jp`.
Use a rental search under `/chintai/` or a used-condo search under `/ms/chuko/`, not an individual detail URL.

#### The run fails after retries

Open the run log and identify the affected search URL.
Retry later if SUUMO returned a temporary 5xx response.
Reduce simultaneous runs before increasing limits.
A challenge page is treated as a failure, not as zero results.

#### I received fewer rows than `maxItems`

`maxItems` is a ceiling, not a promised count.
The selected search may have fewer pages, filters can reject records, duplicates are removed, or `maxPagesPerUrl` may stop first.

#### Why is a field null?

Rental and sale cards expose different attributes.
The schema remains stable by using null for unavailable scalar fields and empty arrays for absent access, image, or tag lists.

### Legal and responsible use

This Actor extracts publicly displayed result-card data.
You are responsible for complying with SUUMO's terms, robots guidance, applicable database rights, copyright, privacy rules, and local law.
Use reasonable limits and a legitimate purpose.
Do not use the Actor to harass property owners or agents, republish protected media, infer sensitive personal information, or bypass access controls.

The Actor is unofficial and is not affiliated with or endorsed by SUUMO or Recruit.
Source availability and HTML structure can change without notice.

### Related Automation Lab Actors

For comparable international property workflows, see:

- [Fotocasa Property Listings Scraper](https://apify.com/automation-lab/fotocasa-property-listings-scraper) for Spanish listings;
- [ImmoScout24 Property Listings Scraper](https://apify.com/automation-lab/immoscout24-property-scraper) for German listings;
- [Aqarmap Egypt Property Listings Scraper](https://apify.com/automation-lab/aqarmap-egypt-property-listings-scraper) for Egyptian listings.

These are separate sources and do not enrich or replace SUUMO records.

### FAQ

#### Does it require a SUUMO login?

No. It accepts public supported search-result URLs.

#### Does it support rental and sale listings in one run?

Yes. Add rental and used-condo search URLs to the same input.
The unified `listingType` field distinguishes them.

#### Does it scrape every type of property sale?

No. The current sale parser supports used-condominium search results.
New condos, houses, land, commercial properties, and detail-only URLs are not claimed.

#### Can I monitor changes automatically?

Yes. Save the input as an Apify Task and schedule it.
Store each run's dataset downstream, then compare stable IDs and normalized values.

#### Are prices final transaction prices?

No. They are asking rents or asking sale prices displayed in SUUMO search results at collection time.

#### Are image files stored in my dataset?

No. The dataset contains public image URLs exposed by the result card; the Actor does not download image binaries.

#### Can I export to CSV or Excel?

Yes. Use the default dataset's export controls or API endpoints.
Array fields are serialized according to the selected export format.

# Actor input Schema

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

Public suumo.jp rental or used-condo result URLs. Configure location, price, layout, station, and other criteria on SUUMO before copying the URL.

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

Stop after this many unique property listing rows across all URLs.

## `maxPagesPerUrl` (type: `integer`):

Maximum result pages followed for each search URL.

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

Optionally retain only rental or sale records. The source URL must still be a matching SUUMO search.

## `minPriceYen` (type: `integer`):

Optional inclusive minimum monthly rent or sale price in Japanese yen.

## `maxPriceYen` (type: `integer`):

Optional inclusive maximum monthly rent or sale price in Japanese yen.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://suumo.jp/chintai/tokyo/sc_shinjuku/"
    }
  ],
  "maxItems": 20,
  "maxPagesPerUrl": 3
}
```

# Actor output Schema

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

Default dataset view containing normalized SUUMO property identity, price, attributes, location, images, and source links.

# 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 = {
    "startUrls": [
        {
            "url": "https://suumo.jp/chintai/tokyo/sc_shinjuku/"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/suumo-japan-property-listings-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 = {
    "startUrls": [{ "url": "https://suumo.jp/chintai/tokyo/sc_shinjuku/" }],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/suumo-japan-property-listings-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 '{
  "startUrls": [
    {
      "url": "https://suumo.jp/chintai/tokyo/sc_shinjuku/"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/suumo-japan-property-listings-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/suumo-japan-property-listings-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/xb1bHbMaOdkAGd3bb/builds/AaO4nhl8Bon2UwUBl/openapi.json