# Zigbang Scraper - Korea Real Estate Listings & Agents (`haketa/zigbang-scraper`) Actor

Zigbang scraper & data API for South Korea real estate: search officetels, villas & one-room studios for monthly rent (월세), jeonse (전세) & sale; export price, deposit, size, floor, address, photos plus the listing agent name & phone. Korea property data & lead-gen — fast, no login.

- **URL**: https://apify.com/haketa/zigbang-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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/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

## Zigbang Scraper — South Korea Real Estate Listings, Prices & Agents

Extract **South Korean property listings** from Zigbang at scale: officetels, villas, and one-room studios for **monthly rent (월세)**, **jeonse (전세)**, and **sale (매매)**. Search by Korean location name, filter by deposit and rent, and export clean, structured data — including **price, deposit, size, floor, address, photos, options, nearby subway stations, and the listing agent's name and phone number**.

No login. No browser hassle. Just give it a neighborhood, a district, or a list of URLs, and get back a ready-to-use dataset in JSON, CSV, Excel, or via API.

> Built for proptech teams, relocation and expat-housing services, market analysts, and anyone who needs Korean rental and sale data in bulk.

---

### 🧭 Table of contents

- [What this scraper does](#what-this-scraper-does)
- [Why use it](#why-use-it)
- [Who it's for](#who-its-for)
- [What data you get](#what-data-you-get)
- [Input options](#input-options)
- [Input examples](#input-examples)
- [Output example](#output-example)
- [How to use (step by step)](#how-to-use-step-by-step)
- [Tips for best results](#tips-for-best-results)
- [Use cases](#use-cases)
- [Integrations & export](#integrations--export)
- [Pricing](#pricing)
- [FAQ](#faq)

---

### What this scraper does

Zigbang is one of South Korea's most popular mobile-first real-estate platforms, with a huge inventory of rooms, officetels, and villas. This actor turns that inventory into a structured dataset you can actually work with.

You can collect listings in three ways:

1. **By location search** — type a Korean district (구), neighborhood (동), subway station, or building name (e.g. `강남구`, `역삼동`, `홍대입구역`). The actor geocodes it and scrapes the surrounding area.
2. **By URL** — paste specific Zigbang listing URLs and get their full detail records.
3. **By item ID** — feed numeric listing IDs directly.

For every listing it returns a complete record: pricing, size, floor, direction, options, maintenance cost, full address, GPS coordinates, photos, nearby subway lines, and the **realtor's contact details**.

---

### Why use it

- ⚡ **Fast & lightweight** — pulls structured data directly, with no slow browser rendering.
- 🇰🇷 **Korea-native** — understands 월세 / 전세 / 매매, room types, officetels, villas, and pyeong (평) vs. m².
- 🌐 **English-friendly** — optionally adds English translations for sales type, room type, and floor level, so non-Korean teams can read the data instantly.
- 🏢 **Agent contacts included** — every listing carries the listing office name, agent name, and phone number — invaluable for outreach and lead generation.
- 🧱 **Flexible inputs** — search terms, URLs, or IDs, with deposit/rent filters and adjustable area coverage.
- 📦 **Export anywhere** — JSON, CSV, Excel, HTML table, or RSS, plus a full REST API and integrations.

---

### Who it's for

- **Proptech & real-estate startups** building search, valuation, or analytics products for the Korean market.
- **Relocation & expat-housing services** that need to surface rooms and officetels for clients moving to Seoul, Busan, or beyond.
- **Market researchers & analysts** tracking rent levels, deposit trends, and supply across districts.
- **Lead-generation teams** that want agent and office contact details at scale.
- **Investors & landlords** monitoring competing listings and pricing in target neighborhoods.

---

### What data you get

Each listing in the dataset includes (when available):

| Field | Description |
| --- | --- |
| `itemId` | Unique Zigbang listing ID |
| `url` | Direct link to the listing |
| `salesType` | 월세 / 전세 / 매매 / 단기 (sale type) |
| `salesTypeEn` | English: Monthly rent / Jeonse / Sale / Short-term |
| `serviceType` | Property type (원룸 / 빌라 / 오피스텔 …) |
| `serviceTypeEn` | English property type |
| `roomType` | Room layout (원룸 / 투룸 / 쓰리룸 …) |
| `roomTypeEn` | English room layout |
| `deposit` | Deposit in 만원 (10,000 KRW units) |
| `rent` | Monthly rent in 만원 |
| `depositKRW` / `rentKRW` | Same values converted to KRW |
| `maintenanceCost` | Monthly maintenance / management fee |
| `areaM2` | Exclusive area in square meters |
| `contractAreaM2` | Contract area in square meters |
| `areaPyeong` | Exclusive area in 평 (pyeong) |
| `floor` / `totalFloors` | Floor level and total floors of the building |
| `roomDirection` | Facing direction of the unit |
| `bathroomCount` | Number of bathrooms |
| `elevator` | Whether the building has an elevator |
| `parkingAvailable` / `parkingCount` | Parking availability and capacity |
| `moveinDate` | Move-in availability |
| `approveDate` | Building approval (construction) date |
| `options` | Built-in options (aircon, fridge, washer, induction…) |
| `residenceType` | Residence classification |
| `title` | Listing title |
| `description` | Full listing description |
| `address` | Full administrative address |
| `sido` / `sigungu` / `dong` | City / district / neighborhood |
| `jibunAddress` | Lot-number (지번) address |
| `lat` / `lng` | GPS coordinates |
| `subways` | Nearby subway stations and their lines |
| `agentName` | Listing agent name |
| `agentOffice` | Agency / office name |
| `agentPhone` | Agent phone number |
| `agentType` | Agent role (e.g. representative broker) |
| `agentAddress` | Agency address |
| `viewCount` | Listing view count |
| `status` | Listing status |
| `thumbnail` / `images` | Photo URLs |
| `updatedAt` | Last update timestamp |
| `scrapedAt` | When the record was scraped |

---

### Input options

| Option | Type | Description |
| --- | --- | --- |
| `searchQueries` | array | Korean location names (district, neighborhood, subway, building). |
| `salesTypes` | array | Which listing types to include: 월세, 전세, 매매, 단기. |
| `propertyUrls` | array | Direct Zigbang listing URLs. |
| `itemIds` | array | Direct numeric listing IDs. |
| `geohashes` | array | Advanced: query map tiles by geohash directly. |
| `depositMin` / `depositMax` | integer | Deposit range in 만원. |
| `rentMin` / `rentMax` | integer | Monthly rent range in 만원. |
| `geohashPrecision` | integer | Tile size: 5 ≈ 4.9 km (default), 6 ≈ 1.2 km (finer). |
| `gridRadius` | integer | Coverage around each search center: 0 = single tile, 1 = 3×3 (default), 2 = 5×5. |
| `includeEnglish` | boolean | Add English translations for Korean fields (default: true). |
| `maxItems` | integer | Maximum listings to save (0 = no limit). |
| `maxConcurrency` | integer | Parallel detail requests (default: 10). |
| `proxyConfiguration` | object | Proxy settings — Korean (KR) residential recommended at scale. |

---

### Input examples

#### 1. Search a district for monthly rentals

```json
{
  "searchQueries": ["강남구"],
  "salesTypes": ["월세"],
  "maxItems": 500,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

#### 2. Multiple neighborhoods, rent + jeonse, with a budget filter

```json
{
  "searchQueries": ["역삼동", "마포구", "홍대입구역"],
  "salesTypes": ["월세", "전세"],
  "rentMax": 100,
  "depositMax": 5000,
  "maxItems": 1000,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

#### 3. Specific listings by URL

```json
{
  "propertyUrls": [
    "https://www.zigbang.com/home/oneroom/items/48964085",
    "https://www.zigbang.com/home/oneroom/items/49165383"
  ]
}
```

#### 4. Wide coverage of a district

```json
{
  "searchQueries": ["송파구"],
  "salesTypes": ["월세", "전세"],
  "gridRadius": 2,
  "maxItems": 2000,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

***

### Output example

```json
{
  "itemId": 48964085,
  "url": "https://www.zigbang.com/home/oneroom/items/48964085",
  "salesType": "월세",
  "salesTypeEn": "Monthly rent",
  "serviceType": "오피스텔",
  "serviceTypeEn": "Officetel",
  "roomType": "쓰리룸",
  "roomTypeEn": "Three-room",
  "deposit": 500,
  "rent": 500,
  "depositKRW": 5000000,
  "rentKRW": 5000000,
  "maintenanceCost": 0,
  "areaM2": 64.3,
  "contractAreaM2": 170.86,
  "areaPyeong": 19.45,
  "floor": "중",
  "totalFloors": "20",
  "options": ["에어컨", "냉장고", "세탁기", "인덕션", "싱크대"],
  "address": "서울특별시 서초구 서초동",
  "sido": "서울특별시",
  "sigungu": "서초구",
  "dong": "서초동",
  "lat": 37.4853755,
  "lng": 127.0329492,
  "subways": [{ "name": "양재역", "lines": "3호선,신분당선" }],
  "agentName": "박영준",
  "agentOffice": "박영준공인중개사사무소",
  "agentPhone": "025555706",
  "agentType": "대표공인중개사",
  "images": ["https://.../1.jpg", "https://.../2.jpg"],
  "updatedAt": "2026-05-09 16:11:51",
  "scrapedAt": "2026-06-07T10:00:00.000Z"
}
```

***

### How to use (step by step)

1. Click **Try for free** / open the actor.
2. In **Location searches**, add one or more Korean place names (e.g. `강남구`, `역삼동`).
3. Pick your **Listing / sales types** — monthly rent, jeonse, sale, or short-term.
4. (Optional) Set **deposit** and **rent** ranges to match your budget.
5. (Optional) Adjust **grid radius** for wider or tighter geographic coverage.
6. Set **Max items** to control dataset size.
7. Click **Save & Start**.
8. When the run finishes, open the **Storage / Dataset** tab and export to JSON, CSV, Excel, or pull it via API.

***

### Tips for best results

- **Use a proxy.** A proxy is strongly recommended, and **Korean (KR) residential** proxies give the most reliable results when scraping large volumes.
- **Start narrow, then widen.** Begin with `gridRadius: 0` or `1` and a modest `maxItems` to preview results, then scale up.
- **Mind the units.** Deposit and rent are in **만원** (1 = 10,000 KRW). A rent of `70` means 700,000 KRW/month. Use `depositKRW` / `rentKRW` for absolute values.
- **Search precisely.** A neighborhood (동) gives tighter, more relevant results than a whole city; a district (구) with `gridRadius: 1` covers a broad area.
- **Combine inputs.** You can mix `searchQueries`, `propertyUrls`, and `itemIds` in a single run.

***

### Use cases

- 🏠 **Rental market dashboards** — track 월세 and 전세 levels by district over time.
- 📊 **Pricing & valuation models** — feed deposit, rent, size, and floor data into AVM/analytics pipelines.
- 🧲 **Agent lead generation** — build contact lists of active listing offices and brokers.
- 🌏 **Relocation & expat platforms** — surface available rooms and officetels for incoming residents.
- 🔍 **Competitive monitoring** — watch competing listings in your target neighborhoods.
- 🤖 **AI & data products** — supply fresh, structured Korean property data to apps and assistants.

***

### Integrations & export

Export your results as **JSON, CSV, Excel, HTML table, or RSS**, or fetch them through the **API**. Connect the actor to **Make, Zapier, n8n, Google Sheets, Slack, GitHub**, and more, or schedule runs to keep your dataset fresh automatically.

***

### Pricing

This actor runs on a simple, predictable pay-per-result model. You only pay for the listings you successfully collect — start small with the free tier and scale up as you need more data.

***

### FAQ

**Which property types are covered?**
One-room studios, officetels, and villas across monthly rent, jeonse, sale, and short-term listings.

**Can I get the agent's phone number?**
Yes — when the listing exposes it, the agent name, office, and phone number are included.

**Do I need a Zigbang account or API key?**
No. No login or key is required.

**In what units are deposit and rent?**
In 만원 (10,000 KRW). The dataset also includes `depositKRW` and `rentKRW` for absolute KRW values.

**How do I cover an entire district?**
Use the district name (e.g. `송파구`) as a search query and increase `gridRadius` to `2` for wider coverage.

**How many listings can I scrape?**
As many as you need — set `maxItems` to `0` for no limit. For large runs, use a Korean residential proxy.

**Can non-Korean speakers use the output?**
Yes. Keep `includeEnglish` enabled to get English translations of sales type, room type, and floor level alongside the original Korean.

**What if a search returns no results?**
Check that the location name is spelled in Korean and that your `salesTypes` and price filters aren't too restrictive.

***

Need another Korean data source or a custom field? Open an issue on the actor's **Issues** tab — feedback and feature requests are welcome.

# Actor input Schema

## `searchQueries` (type: `array`):

Korean location names to search — district (구), neighborhood (동), subway station or building name. Examples: 강남구, 역삼동, 홍대입구역. Each is geocoded and the surrounding area is scraped.

## `salesTypes` (type: `array`):

Which listing types to include. 월세 = monthly rent, 전세 = jeonse (lump-sum deposit), 매매 = sale, 단기 = short-term.

## `propertyUrls` (type: `array`):

Direct Zigbang listing URLs (e.g. https://www.zigbang.com/home/oneroom/items/48964085). The item id is extracted from each URL.

## `itemIds` (type: `array`):

Direct Zigbang numeric item IDs to scrape.

## `geohashes` (type: `array`):

Advanced: query item tiles by geohash directly instead of by location search.

## `depositMin` (type: `integer`):

Minimum deposit in 만원 (1 = 10,000 KRW). Leave empty for no minimum.

## `depositMax` (type: `integer`):

Maximum deposit in 만원 (1 = 10,000 KRW). Leave empty for no maximum.

## `rentMin` (type: `integer`):

Minimum monthly rent in 만원. Leave empty for no minimum.

## `rentMax` (type: `integer`):

Maximum monthly rent in 만원. Leave empty for no maximum.

## `geohashPrecision` (type: `integer`):

Tile size for location searches. 5 ≈ 4.9 km tile (default), 6 ≈ 1.2 km (finer, more requests).

## `gridRadius` (type: `integer`):

How many tile rings around each search center to cover. 0 = single tile, 1 = 3×3 grid (default, covers a district), 2 = 5×5 (wider).

## `includeEnglish` (type: `boolean`):

Add English translations for Korean enum fields (sales type, room type, floor level).

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

Maximum number of listings to save. 0 = no limit.

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

Maximum parallel detail requests.

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

Proxy settings. A proxy is strongly recommended. Korean (KR) residential proxies give the best reliability at scale.

## Actor input object example

```json
{
  "searchQueries": [
    "강남구",
    "마포구"
  ],
  "salesTypes": [
    "월세",
    "전세"
  ],
  "geohashPrecision": 5,
  "gridRadius": 1,
  "includeEnglish": true,
  "maxItems": 200,
  "maxConcurrency": 10,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listings` (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 = {
    "searchQueries": [
        "역삼동"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/zigbang-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 = {
    "searchQueries": ["역삼동"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/zigbang-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 '{
  "searchQueries": [
    "역삼동"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/zigbang-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zigbang Scraper - Korea Real Estate Listings & Agents",
        "description": "Zigbang scraper & data API for South Korea real estate: search officetels, villas & one-room studios for monthly rent (월세), jeonse (전세) & sale; export price, deposit, size, floor, address, photos plus the listing agent name & phone. Korea property data & lead-gen — fast, no login.",
        "version": "0.1",
        "x-build-id": "ZHCuESla8cq0LeTOy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/haketa~zigbang-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-haketa-zigbang-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/haketa~zigbang-scraper/runs": {
            "post": {
                "operationId": "runs-sync-haketa-zigbang-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/haketa~zigbang-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-haketa-zigbang-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": {
                    "searchQueries": {
                        "title": "Location searches (Korean)",
                        "type": "array",
                        "description": "Korean location names to search — district (구), neighborhood (동), subway station or building name. Examples: 강남구, 역삼동, 홍대입구역. Each is geocoded and the surrounding area is scraped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "salesTypes": {
                        "title": "Listing / sales types",
                        "type": "array",
                        "description": "Which listing types to include. 월세 = monthly rent, 전세 = jeonse (lump-sum deposit), 매매 = sale, 단기 = short-term.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "월세",
                                "전세",
                                "매매",
                                "단기"
                            ],
                            "enumTitles": [
                                "월세 (Monthly rent)",
                                "전세 (Jeonse)",
                                "매매 (Sale)",
                                "단기 (Short-term)"
                            ]
                        },
                        "default": [
                            "월세",
                            "전세"
                        ]
                    },
                    "propertyUrls": {
                        "title": "Zigbang listing URLs",
                        "type": "array",
                        "description": "Direct Zigbang listing URLs (e.g. https://www.zigbang.com/home/oneroom/items/48964085). The item id is extracted from each URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "itemIds": {
                        "title": "Item IDs",
                        "type": "array",
                        "description": "Direct Zigbang numeric item IDs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "geohashes": {
                        "title": "Geohashes (advanced)",
                        "type": "array",
                        "description": "Advanced: query item tiles by geohash directly instead of by location search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "depositMin": {
                        "title": "Min deposit (만원 / 10,000 KRW)",
                        "type": "integer",
                        "description": "Minimum deposit in 만원 (1 = 10,000 KRW). Leave empty for no minimum."
                    },
                    "depositMax": {
                        "title": "Max deposit (만원 / 10,000 KRW)",
                        "type": "integer",
                        "description": "Maximum deposit in 만원 (1 = 10,000 KRW). Leave empty for no maximum."
                    },
                    "rentMin": {
                        "title": "Min monthly rent (만원 / 10,000 KRW)",
                        "type": "integer",
                        "description": "Minimum monthly rent in 만원. Leave empty for no minimum."
                    },
                    "rentMax": {
                        "title": "Max monthly rent (만원 / 10,000 KRW)",
                        "type": "integer",
                        "description": "Maximum monthly rent in 만원. Leave empty for no maximum."
                    },
                    "geohashPrecision": {
                        "title": "Geohash precision",
                        "minimum": 4,
                        "maximum": 7,
                        "type": "integer",
                        "description": "Tile size for location searches. 5 ≈ 4.9 km tile (default), 6 ≈ 1.2 km (finer, more requests).",
                        "default": 5
                    },
                    "gridRadius": {
                        "title": "Search grid radius",
                        "minimum": 0,
                        "maximum": 3,
                        "type": "integer",
                        "description": "How many tile rings around each search center to cover. 0 = single tile, 1 = 3×3 grid (default, covers a district), 2 = 5×5 (wider).",
                        "default": 1
                    },
                    "includeEnglish": {
                        "title": "Add English fields",
                        "type": "boolean",
                        "description": "Add English translations for Korean enum fields (sales type, room type, floor level).",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "type": "integer",
                        "description": "Maximum number of listings to save. 0 = no limit.",
                        "default": 200
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Maximum parallel detail requests.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. A proxy is strongly recommended. Korean (KR) residential proxies give the best reliability at scale.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```