# Suumo - Japanese Real Estate (`swerve/suumo-scraper`) Actor

Pulls rent and sale listings from suumo.jp, Japan's #1 real estate portal. Covers all 23 Tokyo wards plus Yokohama, Osaka, Kyoto, Nagoya, Sapporo, Fukuoka and more. Returns rent, deposit, key money, layout, area, building age, train access, and full image gallery.

- **URL**: https://apify.com/swerve/suumo-scraper.md
- **Developed by:** [Swerve](https://apify.com/swerve) (community)
- **Categories:** Real estate, Travel
- **Stats:** 2 total users, 1 monthly users, 88.9% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 listings

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

## Suumo Scraper - Japanese Real Estate API

Extract real estate listings from [suumo.jp](https://suumo.jp), Japan's #1 property portal. Returns rich structured data per listing: rent, deposit, key money, layout, floor area, building age, train access, and full image gallery.

### What you get per listing

- listingId, url - Suumo listing token and direct link
- listingType - rent or sale
- propertyType - Japanese property label (e.g. 賃貸マンション, 賃貸アパート, 中古マンション)
- buildingName - Building name in Japanese
- address - Full address in Japanese
- city - Ward or city parsed from the address (e.g. 渋谷区, 横浜市)
- trainAccess - Array of train lines + walking time to nearest stations
- rentPriceYen, managementFeeYen - Monthly rent and management fee in JPY (rent only)
- depositYen (敷金), keyMoneyYen (礼金) - Standard Japanese upfront fees (rent only)
- salePriceYen - Total sale price in JPY (sale only)
- layout - Layout code 1K, 1LDK, 3LDK, etc.)
- areaSqm, floor, buildingAgeYears, totalFloors
- imageUrl, imageUrls - Cover + full gallery
- scrapedAt

### How to use

Type a Japanese city or Tokyo ward, pick rent or sale.

```json
{ "city": "Shibuya", "listingType": "rent", "maxItems": 200 }
````

Other examples:

```json
{ "city": "Minato",   "listingType": "rent", "maxItems": 100 }
{ "city": "Osaka",    "listingType": "rent", "maxItems": 100 }
{ "city": "Yokohama", "listingType": "sale", "maxItems": 50  }
{ "city": "Kyoto",    "listingType": "rent", "maxItems": 100 }
```

Supported cities: all 23 Tokyo wards (Chiyoda, Chuo, Minato, Shinjuku, Bunkyo, Taito, Sumida, Koto, Shinagawa, Meguro, Ota, Setagaya, Shibuya, Nakano, Suginami, Toshima, Kita, Arakawa, Itabashi, Nerima, Adachi, Katsushika, Edogawa) plus Yokohama, Kawasaki, Saitama, Chiba, Osaka, Kyoto, Kobe, Nagoya, Sapporo, Fukuoka, Sendai, Hiroshima.

Power-user mode: for finer filters (price range, layout, station distance, min year built), set them on suumo.jp, copy the URL from your browser, paste into searchUrl. The structured inputs are bypassed.

### Common use cases

Investor monitoring - track new listings across Tokyo, Osaka, Yokohama. Compare yields by ward.

Relocation agencies - source apartments for expat clients moving to Japan.

Real estate funds - portfolio-track rent levels and vacancy signals across major Japanese markets.

Price benchmarking - rent per square meter by city and layout.

### Pricing

Pay per result. See the Pricing tab. Failed runs cost nothing.

### Notes

Each Suumo "building" can have multiple rooms listed; each room is returned as a separate listing.

Pagination is automatic, set your desired maxItems and the actor walks through pages until it has enough or runs out.

Deposit (敷金) and key money (礼金) are non-refundable Japanese rental upfront fees, typically 1-2 months of rent each.

### Tags

japan, tokyo, suumo, real estate, property, rental, apartment, chintai, japanese real estate

Found a bug or have a feature request? Open an issue and I respond within 24h.

# Actor input Schema

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

Japanese city or Tokyo ward (e.g. 'Shibuya', 'Shinjuku', 'Minato', 'Osaka', 'Kyoto', 'Yokohama'). Required unless 'Search URL' is set. Supported: all 23 Tokyo wards plus Yokohama, Kawasaki, Saitama, Chiba, Osaka, Kyoto, Kobe, Nagoya, Sapporo, Fukuoka, Sendai, Hiroshima.

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

Rent (chintai/賃貸) or sale (used apartment, chuko/中古マンション).

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

Maximum number of listings to return.

## `searchUrl` (type: `string`):

Optional. Power-user override. Set your filters on suumo.jp (price range, layout, station distance, etc.), copy the URL from your browser, paste here. Bypasses the structured inputs above.

## Actor input object example

```json
{
  "city": "Shibuya",
  "listingType": "rent",
  "maxItems": 100
}
```

# 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 = {
    "city": "Shibuya"
};

// Run the Actor and wait for it to finish
const run = await client.actor("swerve/suumo-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 = { "city": "Shibuya" }

# Run the Actor and wait for it to finish
run = client.actor("swerve/suumo-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 '{
  "city": "Shibuya"
}' |
apify call swerve/suumo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Suumo - Japanese Real Estate",
        "description": "Pulls rent and sale listings from suumo.jp, Japan's #1 real estate portal. Covers all 23 Tokyo wards plus Yokohama, Osaka, Kyoto, Nagoya, Sapporo, Fukuoka and more. Returns rent, deposit, key money, layout, area, building age, train access, and full image gallery.",
        "version": "1.0",
        "x-build-id": "zjPajLsb7rxCFzGHA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/swerve~suumo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-swerve-suumo-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/swerve~suumo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-swerve-suumo-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/swerve~suumo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-swerve-suumo-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": {
                    "city": {
                        "title": "City or Tokyo ward",
                        "type": "string",
                        "description": "Japanese city or Tokyo ward (e.g. 'Shibuya', 'Shinjuku', 'Minato', 'Osaka', 'Kyoto', 'Yokohama'). Required unless 'Search URL' is set. Supported: all 23 Tokyo wards plus Yokohama, Kawasaki, Saitama, Chiba, Osaka, Kyoto, Kobe, Nagoya, Sapporo, Fukuoka, Sendai, Hiroshima."
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "rent",
                            "sale"
                        ],
                        "type": "string",
                        "description": "Rent (chintai/賃貸) or sale (used apartment, chuko/中古マンション).",
                        "default": "rent"
                    },
                    "maxItems": {
                        "title": "Max listings",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 100
                    },
                    "searchUrl": {
                        "title": "Search URL (advanced)",
                        "type": "string",
                        "description": "Optional. Power-user override. Set your filters on suumo.jp (price range, layout, station distance, etc.), copy the URL from your browser, paste here. Bypasses the structured inputs above."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
