# goo Housing Rentals (goo住宅・不動産) - New Listings by Area (`superslowsloth/goo-housing`) Actor

goo住宅・不動産 (house.goo.ne.jp) rental search, one flat row per room: rent, admin fee, deposit, key money, guarantee deposit, layout, area, floor, building age, access lines, feature tags and a NEW flag. Search by a pasted goo search URL or by JIS city code, newest-first.

- **URL**: https://apify.com/superslowsloth/goo-housing.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.40 / 1,000 listing scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## goo Housing Rentals (goo住宅・不動産) — new listings by area

Runs a [goo住宅・不動産](https://house.goo.ne.jp/rent/) rental search and
returns one flat row per **room**, not per building. goo's results page groups
rooms into building cards - one card per building, with a row for every room
currently advertised in it - and a building with six vacant rooms produces six
rows here, sharing the building's name, address, access lines and age, and
differing in the room-level fields: floor, rent, fees, layout and area.

Sorted newest-first by default, so a scheduled run per area works as a
new-listing alert: goo's own "NEW" icon is carried on every row as `is_new`.

### Input

Give it either a search URL, or one or more city/ward codes - both can be
combined in one run.

| Field | Type | Default | What it does |
|---|---|---|---|
| `searchUrls` | array | — | Listing URLs copied from house.goo.ne.jp: an area page (`https://house.goo.ne.jp/rent/shuto_ap/area_tokyo/13101.html`, 千代田区), a station page (`/rent/shuto_ap/ensen/345/2345090.html`), or a `/rent/ap/result.html?...` search. Every filter already on the URL survives; only the page number is driven by this actor. |
| `cityCodes` | array | — | JIS municipality codes, e.g. `"13101"` (千代田区) or `"13201"` (八王子市) - the number at the end of a goo area URL. goo's six-digit whole-city codes (`"010001"`, all of 札幌市) work too. The prefecture and goo's region path are worked out from the first two digits. |
| `prefecture` | string | — | Optional check: a prefecture number (`"13"`) or goo's own slug (`"tokyo"`, `"oosaka"`) that every city code must belong to. |
| `sortNewest` | boolean | `true` | Ask goo for its own "新着更新順" (newest / newly updated first) order. Turn off to keep whatever sort a pasted URL carries. |
| `maxItems` | integer | `100` | Stop after this many rooms across every search in the run. |
| `proxyConfiguration` | object | Apify datacenter | See Proxy below. |

### What one row contains

| Field | Notes |
|---|---|
| `room_id`, `detail_url` | `room_id` is goo's own listing id - the row's checkbox value, and the `x<id>.html` file name of the detail link. The billing key. |
| `feed_code`, `city_code` | goo aggregates listings from partner portals; `feed_code` is the digit in the detail link that says which feed a row came through. The page never names the partner, so neither does this actor. `city_code` is the JIS code in the same link. |
| `building_name` | The card's title, as goo prints it. For a building it has no name for, goo prints the address, age and floor count instead (e.g. "東京都千代田区神田猿楽町２丁目 13階建 ...") - genuinely what the page shows, not a parsing gap. |
| `building_type`, `address`, `access` | 賃貸マンション / 賃貸アパート as printed. `access` is one `"<line> <station> 徒歩<N>分"` string per line goo lists; never padded. |
| `building_age_years`, `building_age_months`, `building_age_raw` | "築2年6ヶ月" gives 2 and 6. "築22年" gives 22 and **null** months - goo did not state them. "新築" (newly built) gives 0 years, a real age. |
| `room_floor`, `room_floor_raw` | Negative for a basement floor. |
| `rent_jpy` | Whole yen, from goo's "14.90万円". |
| `admin_fee_jpy`, `admin_fee_raw` | 管理費等 in yen. |
| `deposit_*`, `key_money_*`, `guarantee_deposit_*` | 敷金, 礼金 and 保証金. goo usually quotes these in months of rent ("1ヶ月"), which lands in `_months`; when it quotes yen ("19.4万円") that lands in `_jpy`. `_jpy` is never computed from months - that would be a figure goo did not print. |
| `deposit_amortization_raw` | 敷引・償却 - free text on the page ("解約時1ヶ月償却", "実費"), kept as text. |
| `layout`, `area_m2` | 間取り as printed ("1LDK", "ワンルーム"), and floor area in m². |
| `building_image_url`, `floor_plan_image_url` | The building photo and this room's floor-plan thumbnail, as goo serves them through its own image host. |
| `features`, `recommendation` | goo's feature tags for the room ("礼金なし", "ペット相談可", ...) and the agent's "おすすめポイント" line, as printed. |
| `is_new`, `has_video` | goo's own "NEW" icon and "動画あり" (has video) marker on the row. goo prints no listing date on the results page, so `is_new` - not date math - is the only "new" signal it states. |
| `source_url` | The exact search URL this row was read from, page number included. |

#### Null, never zero

A field the page does not carry is `null`, never `0`. In particular goo prints
two different words for "nothing": **"なし"** (none) and **"-"** (not stated).
Both leave the numeric column (`admin_fee_jpy`, `deposit_jpy`,
`deposit_months`, ...) null; the matching `_raw` column always carries the text
as printed, so a "no key money" filter should read `key_money_raw == "なし"`.
goo's results page does not print a building's total floor count as its own
column, so there is no floors field at all rather than a guessed one.

The same physical flat advertised through two feeds, or by two agents, is two
rows with two `room_id`s - goo lists them separately and this actor does not
merge what goo did not.

### How it pages and sorts

An area's listing is `/rent/<region>_ap/area_<prefecture>/<city code>.html`.
The region and prefecture slugs are goo's own ("kansai\_ap/area\_oosaka",
"hokkaidou\_ap/area\_hokkaido") and are built from a table read off goo's own
links for all 47 prefectures. Paging is `p=N`; `ps=50` asks for 50 buildings a
page (the largest goo's own control offers); newest-first is `sk=9&rev=0`,
read off goo's own sort control, whose "新着更新順" option is value `90`. The
walk ends when goo's pager stops offering "次へ" (next).

A search that matches nothing is an honest empty result: goo prints its own
"条件にあう物件が見つかりませんでした" notice, the run logs it and charges nothing
beyond the start fee. A city code goo does not know is reported as a failure.

### Proxy

Apify **datacenter** is the default and answers goo with real results.

**Never use residential without pinning the country to Japan**
(`apifyProxyCountry: "JP"`): measured 2026-09-28, goo refuses an unpinned
residential exit with HTTP 403. JP-pinned residential works too, but costs
more for no gain. A 403, 429 or 5xx - or any page that arrives as a 200
without goo's listing markup - is treated as a block and retried from a
different exit address, never read as an empty result.

### Billing

Pay per event: **$0.0084 per room**, plus **$0.002** per actor start.
Platform usage - compute and proxy - is included in that price. Competitor
**sian.agency** charges $0.012 per result.

- `listing-scraped` is charged once per room row, deduplicated across every
  search in the run - a room seen on two overlapping searches, or on two pages
  of the same search, is billed once.
- `actor-start` is charged only after your input parses, so a run that fails
  on a typo costs nothing.
- A run stops as soon as it reaches your spending limit; everything already
  pushed and charged stays in the dataset.

# Actor input Schema

## `searchUrls` (type: `array`):

One or more rental listing URLs copied straight from house.goo.ne.jp: an area page such as https://house.goo.ne.jp/rent/shuto\_ap/area\_tokyo/13101.html (千代田区), a station page such as https://house.goo.ne.jp/rent/shuto\_ap/ensen/345/2345090.html, or a /rent/ap/result.html search. Every filter already on the URL is kept; only the page number is driven by this actor (plus the newest-first sort and the 50-per-page size, when the URL does not set its own).

## `cityCodes` (type: `array`):

JIS municipality codes, e.g. "13101" for 千代田区 or "13201" for 八王子市 - the number at the end of a goo area URL. goo's own six-digit whole-city codes ("010001" for all of 札幌市) work too. One search is run per code; the prefecture and goo's region path are worked out from the code's first two digits.

## `prefecture` (type: `string`):

Optional. A prefecture number ("13") or goo's own slug ("tokyo", "oosaka", "hyougo") that every city code above must belong to - a code from another prefecture is reported and skipped instead of searched. Leave empty to skip the check.

## `sortNewest` (type: `boolean`):

Ask goo for its own "新着更新順" (newest / newly updated first) order before paging. On by default, since finding new listings is what this actor is for; turn it off to keep whatever sort a pasted search URL already carries.

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

Stop after this many rooms across all searches in this run. One room is one billed row; a building with several vacant rooms counts as several.

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

Apify datacenter is the default and answers goo with real results. Never use residential without pinning the country to Japan (apifyProxyCountry "JP"): an unpinned residential exit is refused by goo with HTTP 403. JP-pinned residential works, but costs more for no gain here.

## Actor input object example

```json
{
  "searchUrls": [
    "https://house.goo.ne.jp/rent/shuto_ap/area_tokyo/13101.html"
  ],
  "sortNewest": true,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `rooms` (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 = {
    "searchUrls": [
        "https://house.goo.ne.jp/rent/shuto_ap/area_tokyo/13101.html"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/goo-housing").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 = {
    "searchUrls": ["https://house.goo.ne.jp/rent/shuto_ap/area_tokyo/13101.html"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/goo-housing").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 '{
  "searchUrls": [
    "https://house.goo.ne.jp/rent/shuto_ap/area_tokyo/13101.html"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call superslowsloth/goo-housing --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,superslowsloth/goo-housing"
        }
    }
}
```

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/OG0HZYqtY8QCQlC0G/builds/YNWJatdEMJEZm74Ho/openapi.json