# SUUMO Scraper — Japan Real Estate, Rent & Sale Listings (`haketa/suumo-scraper`) Actor

Scrape SUUMO (Japan's #1 property portal) rental and for-sale listings: rent/price, deposit & key money, madori layout, floor area (m²), address, train stations + walk time, building age and photos. Fast HTTP, no login.

- **URL**: https://apify.com/haketa/suumo-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Business, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## SUUMO Scraper — Japan Real Estate, Rent & Sale Property Listings (suumo.jp)

[![Runs on Apify](https://img.shields.io/badge/Runs%20on-Apify-00C7FF?logo=apify\&logoColor=white)](https://apify.com/haketa/suumo-scraper)
[![Pricing](https://img.shields.io/badge/Pricing-Pay%20Per%20Result-brightgreen)](https://apify.com/haketa/suumo-scraper)
[![Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel-orange)](https://apify.com/haketa/suumo-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained-Active-success)](https://apify.com/haketa/suumo-scraper)

**Scrape SUUMO** (suumo.jp), Japan's premier #1 real-estate and housing marketplace operated by Recruit, and convert millions of Japanese property listings into structured, high-resolution datasets. This production-ready **SUUMO scraper** extracts both **rental apartments (賃貸マンション/アパート)** and **for-sale real estate (新築・中古マンション, 一戸建て, 土地)** across every Tokyo ward, Japanese prefecture, commuter transit line, and municipality.

Extract comprehensive property attributes including **monthly rent, sale prices, management fees, security deposits (敷金), key money (礼金), Japanese madori layouts (1K, 2LDK, etc.), floor surface area in square meters (m²), room floor levels, building age, full addresses, transit stations with walk times, and primary imagery** — without requiring account logins, private API access, or browser automation overhead.

Export thousands of properties directly to **JSON, CSV, Excel, XML, or integrate via REST API and automated webhooks** in seconds.

> Built for PropTech startups, real estate investment trusts (REITs), relocation agencies, urban development researchers, property valuation models, and B2B lead generation specialists who need fresh **Japanese housing data** at scale.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target Website** | [SUUMO Japan](https://suumo.jp/) (Nationwide property portal) |
| **Transaction Types** | Rental (`/chintai/`), for-sale apartments (`/ms/`, `/chuko/`), houses (`/ikkodate/`), land (`/tochi/`) |
| **Paging Scale** | 1,000+ listings per run with automated multi-page deep pagination |
| **Data Fields** | 18+ normalized attributes per residential unit |
| **Price Standardization** | Japanese 万円 units parsed into exact integer JPY (`12.7万円` → `127000`) |
| **Area & Age Normalization** | Surface area converted to numeric m², building age parsed into numeric years |
| **Transit Intelligence** | Parsed array and joined text of commuter train lines, stations, and walk times |
| **Deduplication** | 100% deduplication on canonical listing URLs with composite fallback keys |
| **Execution Speed** | Fast pure-HTTP architecture (~200 rental units per page in ~45–60s) |
| **Proxy Architecture** | Apify Proxy Datacenter enabled by default for rapid IP rotation |
| **Export Formats** | JSON, CSV, Excel, XML, HTML Table, Apify Dataset API |

***

### 🔎 Why scrape SUUMO?

[SUUMO](https://suumo.jp/) (by Recruit Holdings) is the undisputed center of gravity for Japanese residential real estate. Housing millions of active listings, it serves as the definitive reference for Japanese rental yields, residential real estate valuations, and urbanization metrics. Whether tracking micro-neighborhood rental price shifts across Tokyo's 23 wards or scouting undervalued resale condominiums in Osaka and Fukuoka, SUUMO represents the primary dataset for Japanese housing market intelligence.

However, extracting data from SUUMO at scale presents distinct operational challenges:

- **No Public Data API**: SUUMO does not provide an open REST API for property data exports or algorithmic market screening.
- **Complex Hierarchical Markup**: Rental search results are organized into building-level parent containers (`.cassetteitem`) holding nested sub-tables of individual rental rooms, requiring specialized multi-tier DOM parsing.
- **Localized Data Formats**: Prices are represented with kanji multipliers (`12.8万円`), layouts adhere to Japanese spatial terminology (1R, 1K, 2LDK), and building construction ages mix era years and anniversary dates.
- **Massive Inventory Scale**: High-density urban areas like Shinjuku or Shibuya pack hundreds of individual room listings per single result page.

This **SUUMO data extractor** solves these obstacles completely: auto-dispatching between rental and for-sale schemas based on URL structure, flattening hierarchical room tables into discrete rows, standardizing Japanese currency units to pure integer yen, and deduplicating inventory.

#### Key commercial use cases

- **Algorithmic Rental Yield Screening**: Benchmark gross rental yields across transit corridors by comparing purchase asking prices against prevailing neighborhood rents per square meter.
- **Automated Relocation Shortlists**: Real estate agencies catering to expatriates and corporate relocations can generate customized, live housing feeds filtered by transit line and layout.
- **PropTech Valuation Engine Feeds**: Feed automated valuation models (AVM) with live market comps, building age depreciation curves, and floor-level premiums.
- **Macroeconomic Housing Research**: Analyze historical housing supply, construction trends, and spatial density across prefectures.
- **Competitive Broker Intelligence**: Track listing volume changes and price reductions across major property management firms.

***

### ✨ Core capabilities

- ✅ **Unified Multi-Type URL Ingestion**: Seamlessly handles rental listings (`/chintai/`), resale condominiums (`/ms/chuko/`), new development homes, detached houses, and land.
- ✅ **Deep 1,000+ Listing Pagination**: Follows SUUMO's `&page=N` URL parameter across dozens of consecutive page batches until your requested quota is fulfilled.
- ✅ **Clean Numeric JPY Price Normalization**: Converts localized Japanese text prices (`15.4万円`) into machine-readable numeric integers (`154000`).
- ✅ **Granular Fee Disaggregation**: Separates base monthly rent from administrative maintenance fees (`adminFee`), security deposits (`deposit` / 敷金), and contractual key money (`keyMoney` / 礼金).
- ✅ **Layout & Area Standardization**: Extracts Japanese madori codes (`madori` such as `1LDK` or `ワンルーム`) and parses floor areas into numeric float square meters (`area` in m²).
- ✅ **Complete Transit Connectivity**: Captures all referenced railway operators, subway lines, station names, and walking times in minutes (`stations`).
- ✅ **Building Specification Details**: Ingests building age in years (`age`), total building floor height (`buildingFloors`), room level (`floor`), and property types.
- ✅ **Lean Pure HTTP Performance**: Operates via optimized HTTP network calls, eliminating browser overhead and maximizing throughput.

***

### 🎯 Practical business applications

#### 1. Real Estate Investment & Cap Rate Modeling

Individual investors and institutional real estate funds can scrape rental listings across designated train lines (e.g., Yamanote Line, Chuo Line) to compute exact median rent per square meter by neighborhood. By joining rental data with historical sale transaction comps, analysts can uncover micro-markets with superior capitalization rates.

#### 2. Corporate Relocation Platforms

Relocation service providers assisting multinational corporations moving personnel to Tokyo or Osaka can automate weekly inventory pulls filtered by specific international school districts, station walk times (< 10 minutes), and modern layout configurations (2LDK+).

#### 3. PropTech Automated Valuation Models (AVM)

Real estate tech platforms building automated property appraisal software can feed fresh SUUMO listings into machine learning pipelines, calibrating price depreciation models against building age, station distance, and building floor elevation.

#### 4. Construction & Urban Planning Analytics

Architecture firms and development consultancies can audit housing stock density, identifying neighborhoods dominated by aging structures (e.g., `age > 35` years) that represent prime candidates for residential redevelopment or seismic retrofitting.

***

### 📥 Input settings

The actor is ready to run immediately with a prefill demonstrating Shinjuku rental properties, while offering full customization for any prefecture or property category.

| Parameter | Type | Default | Prefill | Description |
|---|---|---|---|---|
| `startUrls` | Array | Shinjuku Rentals URL | Shinjuku Rentals URL | One or more SUUMO listing URLs. Apply your desired filters on suumo.jp and paste the result URL. |
| `maxItems` | Integer | `0` | `50` | Maximum unique listings to save across all URLs. `0` = unlimited (bounded by pagination). |
| `maxPages` | Integer | `0` | `0` | Maximum result pages to paginate per URL. `0` = unlimited deep pagination. |
| `maxConcurrency` | Integer | `2` | `2` | Number of listing URLs to process in parallel (1–6). |
| `proxyConfiguration` | Object | Datacenter | Datacenter | Proxy settings. Apify Datacenter proxies provide fast, reliable IP rotation. |

#### Sample configurations

##### 1. Tokyo Shinjuku rental apartments (Default prefill)

```json
{
  "startUrls": [
    { "url": "https://suumo.jp/chintai/tokyo/sc_shinjuku/" }
  ],
  "maxItems": 50,
  "maxPages": 0
}
```

##### 2. Tokyo resale condominiums for sale

```json
{
  "startUrls": [
    { "url": "https://suumo.jp/ms/chuko/tokyo/sc_shinjuku/" }
  ],
  "maxItems": 250,
  "maxPages": 0
}
```

##### 3. Multi-city simultaneous rental extraction (Tokyo & Osaka)

```json
{
  "startUrls": [
    { "url": "https://suumo.jp/chintai/tokyo/sc_shinjuku/" },
    { "url": "https://suumo.jp/chintai/osaka/sc_osakashikitaku/" }
  ],
  "maxItems": 1000,
  "maxPages": 0,
  "maxConcurrency": 2
}
```

***

### 📤 Output data structure

Every item in the Apify dataset represents an individual property unit.

#### Data field dictionary

##### 🏢 Property Identity & Building Specs

| Field | Type | Coverage | Description |
|---|---|---|---|
| `dealType` | String | 🟢 High (100%) | Transaction classification: `rent` or `sale`. |
| `propertyType` | String | 🟢 High (100%) | Property category (賃貸マンション, 賃貸アパート, 中古マンション, 一戸建て). |
| `buildingName` | String | 🟢 High (100%) | Official building or condominium complex name. |
| `floor` | String | 🟡 Conditional | Specific room floor level within the building (e.g., `"3階"`). |
| `buildingFloors` | String | 🟡 Conditional | Total structural height of the building (e.g., `"5階建"`). |
| `age` | Number | 🟢 High (98%+) | Construction age in years (`0` for newly built `新築`). |
| `url` | String | 🟢 High (100%) | Direct canonical URL to the property listing on SUUMO. |
| `imageUrl` | String | 🟢 High (98%+) | Primary exterior or interior promotional photograph URL. |

##### 💴 Financial & Layout Details

| Field | Type | Coverage | Description |
|---|---|---|---|
| `price` | Number | 🟢 High (100%) | Monthly rent or total sale price expressed as an integer in JPY. |
| `adminFee` | Number | 🟡 Conditional | Monthly management and common service fee (管理費・共益費) in JPY. |
| `deposit` | Number | 🟡 Conditional | Required security deposit (敷金) in JPY. Null for deposit-free listings. |
| `keyMoney` | Number | 🟡 Conditional | Non-refundable contractual key money (礼金) in JPY. Null when zero. |
| `madori` | String | 🟢 High (100%) | Spatial layout classification (e.g., `1K`, `1DK`, `2LDK`, `ワンルーム`). |
| `area` | Number | 🟢 High (100%) | Usable floor surface area measured in numeric square meters (m²). |

##### 🚉 Location & Transit Connectivity

| Field | Type | Coverage | Description |
|---|---|---|---|
| `address` | String | 🟢 High (100%) | Complete Japanese address (Prefecture, Ward/City, Town/District). |
| `stations` | Array | 🟢 High (100%) | Array of commuter transit lines and stations with walking minutes. |
| `stationsText` | String | 🟢 High (100%) | Concatenated, slash-delimited string of all nearby transit stations. |
| `scrapedAt` | String | 🟢 High (100%) | ISO 8601 UTC timestamp of data acquisition. |

***

#### Real JSON output record

```json
{
  "dealType": "rent",
  "propertyType": "賃貸マンション",
  "buildingName": "ハーモニーレジデンス新宿四谷",
  "price": 163000,
  "adminFee": 20000,
  "deposit": null,
  "keyMoney": null,
  "madori": "1DK",
  "area": 25.52,
  "floor": "3階",
  "age": 7,
  "buildingFloors": "5階建",
  "address": "東京都新宿区大京町",
  "stations": [
    "東京メトロ丸ノ内線/四谷三丁目駅 歩7分",
    "ＪＲ中央線/信濃町駅 歩9分",
    "都営大江戸線/国立競技場駅 歩12分"
  ],
  "stationsText": "東京メトロ丸ノ内線/四谷三丁目駅 歩7分 / ＪＲ中央線/信濃町駅 歩9分 / 都営大江戸線/国立競技場駅 歩12分",
  "url": "https://suumo.jp/chintai/jnc_000098292082/",
  "imageUrl": "https://img01.suumo.com/front/gazo/fr/bukken/236/100435816236/100435816236_gw.jpg",
  "scrapedAt": "2026-11-10T14:50:00.000Z"
}
```

***

### 🔁 Deep pagination & scale strategy

1. **High-Density Page Payloads**: A single rental listing page on SUUMO groups numerous individual room units under parent building cassettes, yielding ~100–200 individual property records per page.
2. **Automated `&page=N` Navigation**: The actor systematically increments the pagination index, evaluating HTTP response bodies and parsing new property units until `maxItems` is satisfied or the catalog ends.
3. **Robust Deduplication Keys**: In-memory deduplication checks each record's canonical listing URL. For listings sharing common identifiers, a composite fingerprint (`buildingName|floor|madori|price|area`) ensures strict uniqueness across pagination jumps.
4. **Concurrent Multi-URL Worker Pool**: By leveraging `maxConcurrency`, users can scrape multiple regional URLs simultaneously (e.g., Shinjuku, Minato, Shibuya, and Chuo wards) within a unified run session.

***

### 🛠️ Step-by-step tutorial

1. **Build Your Query on SUUMO**: Visit [suumo.jp](https://suumo.jp/), navigate to your target region, apply your desired filters (e.g., maximum rent, station walk time, minimum floor area), and copy the browser URL.
2. **Add to Apify Input**: In the Apify Console, paste the URL into `startUrls`.
3. **Configure Desired Quota**: Keep `maxItems: 50` for a swift trial run, or enter `1000+` for broad district analysis.
4. **Run the Scraper**: Click **Start**. Live logs will stream parsed property counts in real time.
5. **Export Your Dataset**: Download the results in CSV, Excel, or JSON formats from the **Dataset** tab, or connect via API to your downstream database.

***

### 🏗️ Architecture & Data Extraction Flow

```mermaid
flowchart TD
    A[Start URLs: Rental or For-Sale Search] --> B[URL Dispatcher & Type Detection]
    B -->|Rental /chintai/| C[Rental Cassette Parser]
    B -->|For-Sale /ms/ /chuko/| D[For-Sale Dottable Parser]
    C --> E[Iterate Parent Building Containers]
    E --> F[Extract Sub-Table Room Units]
    D --> G[Extract Unit Key-Value Attribute Map]
    F --> H[Normalize JPY Currency, Area m² & Age]
    G --> H
    H --> I[Parse Train Lines & Walk Minutes]
    I --> J[Deduplicate by Property Key]
    J --> K[Stream Records to Apify Dataset]
    K --> L{MaxItems Reached or End of Pages?}
    L -->|No| M[Fetch Next Page: &page=N]
    M --> B
    L -->|Yes| N[Finalize Run & Save Dataset Output]
```

***

### 📊 Sample Code Integrations

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

## Scrape rental apartments in Shinjuku, Tokyo
run_input = {
    "startUrls": [{"url": "https://suumo.jp/chintai/tokyo/sc_shinjuku/"}],
    "maxItems": 100,
    "maxPages": 0,
}

run = client.actor("haketa/suumo-scraper").call(run_input=run_input)

for prop in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{prop['madori']} - {prop['area']}m²] {prop['buildingName']} - ¥{prop['price']:,}/mo (Age: {prop['age']} yrs)")
```

#### Node.js (apify-client)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('haketa/suumo-scraper').call({
    startUrls: [{ url: 'https://suumo.jp/ms/chuko/tokyo/sc_shinjuku/' }],
    maxItems: 80,
    maxPages: 0,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.table(items, ['buildingName', 'price', 'madori', 'area', 'address']);
```

***

### 🗾 Comparison: Japanese Property Portals

| Metric | SUUMO (suumo.jp) | HOME'S (homes.co.jp) | at home (athome.co.jp) |
|---|---|---|---|
| **Inventory Scale** | Largest in Japan (~7M+ listings) | High (~5M+ listings) | Strong local agency network |
| **Room-Level Detail** | High (nested cassette tables) | Moderate | Moderate |
| **Price Transparency** | Full disaggregation (rent, admin, deposit, key) | Standard | Standard |
| **Search Granularity** | Extensive ward, station, transit walk filters | High | Moderate |
| **Data Scraping Friction**| Lightweight plain HTTP architecture | Heavy dynamic layout | Complex regional portals |

***

### 💡 Practical scraping tips

- **Extracting Free Deposit Listings**: In Japan, rental listings frequently advertise 敷金0 / 礼金0 (zero deposit / zero key money). When these fees are not charged, the dataset values legitimately return `null`.
- **Targeting Commuter Corridors**: On suumo.jp, you can filter listings by entire train lines (e.g., Yamanote Line). Pasting a line-specific URL allows you to evaluate transit-oriented housing across multiple stations.
- **Combining Sale & Rent in One Run**: You can paste both rental URLs and for-sale URLs into `startUrls` simultaneously. The actor automatically applies the respective parser based on URL patterns.
- **Proxy Selection**: SUUMO does not enforce aggressive anti-bot challenges; standard Apify Datacenter proxies provide optimal performance and minimal latency.

***

### ❓ Frequently Asked Questions

**Does this actor require a SUUMO login or credentials?**\
No. The scraper accesses only public listing pages and does not require user accounts, passwords, or authentication cookies.

**How many listings can I extract in a single job?**\
You can extract thousands of listings in a single run. Because rental pages contain up to 200 units per page, a 10-page crawl will typically yield 1,500–2,000 unique records.

**Can I scrape detached houses and land plots?**\
Yes. SUUMO listings for detached houses (`/ikkodate/`) and land plots (`/tochi/`) are fully supported by the for-sale parser.

**Are property images permanent?**\
SUUMO listing photos are hosted on the Recruit image CDN (`img01.suumo.com`). These URLs remain accessible during active property marketing campaigns.

**Can I run this actor on a recurring automated schedule?**\
Yes. You can schedule the actor via Apify Console (e.g., daily at 06:00 JST) to track newly published listings and detect price drops across target neighborhoods.

***

### 🔗 Related Japan & real estate scrapers

- [Tabelog Scraper](https://apify.com/haketa/tabelog-scraper) — Japan's #1 restaurant review, rating, and dining intelligence platform.
- [Rakuten Scraper](https://apify.com/haketa/rakuten-scraper) — Product catalog, pricing, and reviews on Japan's largest e-commerce portal.
- [Mercari Scraper](https://apify.com/haketa/mercari-scraper) — Second-hand goods, resale comps, and C2C marketplace listings in Japan.
- [Avito Scraper](https://apify.com/haketa/avito-scraper) — Real estate listings, apartments, and commercial properties on Avito.

***

#### Understanding Japanese Rental Costs: Shikikin vs. Reikin

When analyzing Japanese rental yields and total move-in expenses, distinguishing between upfront fees is essential:

- **Shikikin (敷金 - Security Deposit)**: Typically 1–2 months of rent. Refundable upon moving out, minus cleaning and repair deductions.
- **Reikin (礼金 - Key Money)**: Non-refundable contractual gratuity paid directly to the landlord, traditionally 1–2 months of rent.
- **Kanrihi / Kyoekihi (管理費・共益費 - Administration Fee)**: Monthly maintenance charge billed in addition to base rent for building upkeep and common areas.
- **Zero-Deposit Trends**: Modern urban rentals increasingly compete by waiving both Shikikin and Reikin (敷金・礼金ゼロゼロ), lowering tenant friction. In the dataset, these properties accurately report `deposit: null` and `keyMoney: null`.

***

**How does the actor handle building age calculations?**\
SUUMO listing markup alternates between anniversary construction dates (`築年月 2018年4月`), direct ages (`築7年`), and new construction flags (`新築`). The scraper unifies all formats into an integer age in years (`age`), mapping brand new properties to `0`.

**Can I filter for pet-friendly or auto-lock properties?**\
Yes. Apply any complex search criteria on suumo.jp (such as pet-friendly ペット相談, auto-lock オートロック, or separate bath/toilet バストイレ別) and copy the generated search URL into `startUrls`. The scraper respects all encoded URL parameters.

***

**Does the scraper output Japanese kanji addresses or romaji?**\
Addresses are returned in standard Japanese municipal hierarchy (e.g., `東京都新宿区大京町`), ensuring exact alignment with official Japanese land registries and GIS mapping tools.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Unlocked Deep 1,000+ Pagination**: Removed restrictive 100-page threshold, enabling unlimited deep pagination across thousands of listings governed by `maxItems`.
- **Fast Prefill Optimization**: Standardized prefill run volume (`50` items) for lightning-fast trial runs under 45 seconds.
- **Enhanced Schema Normalization**: Aligned input, dataset, and output schemas with strict Apify specifications.
- **Refined Area & Currency Parsing**: Improved extraction accuracy for complex Japanese area strings and era-based construction dates.

#### v1.1 (2026-11)

- Implemented dual auto-detect parsers supporting both rental (`.cassetteitem`) and for-sale (`.property_unit`) layouts.
- Added structured station array (`stations`) and normalized transit walking minutes.

#### v1.0 (2026-10)

- Initial production release supporting multi-URL ingestion, price normalization, and URL deduplication.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/suumo-scraper/changelog.md

# Actor input Schema

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

SUUMO search/listing pages. Rental example: https://suumo.jp/chintai/tokyo/sc_shinjuku/ — for-sale example: https://suumo.jp/ms/chuko/tokyo/sc_shinjuku/ . The actor auto-detects rent vs. sale from the URL and paginates each one.

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

Total unique listings to save across all URLs. 0 = no limit (rental pages pack ~200 rooms/page).

## `maxPages` (type: `integer`):

How many result pages to paginate per listing URL (via \&page=N). 0 = unlimited (bounded by maxItems).

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

How many listing URLs to process in parallel.

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

Apify Proxy (datacenter) is recommended for reliable, rotating requests. SUUMO is not anti-bot walled, so residential is NOT required.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://suumo.jp/chintai/tokyo/sc_shinjuku/"
    },
    {
      "url": "https://suumo.jp/ms/chuko/tokyo/sc_shinjuku/"
    }
  ],
  "maxItems": 50,
  "maxPages": 0,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `datasetUi` (type: `string`):

No description

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

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/suumo-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/YieSsK9csmwKxTqgp/builds/xcwz3XSu53j8xoEcM/openapi.json