# Neonet Scraper — South Korea Real Estate Data & API (`sian.agency/neonet-property-scraper`) Actor

neonet.co.kr (부동산뱅크) scraper & real estate data API for South Korea. Extract sale, jeonse & monthly-rent listings — price (KRW), exclusive/supply area, floor, rooms, address, lat/long geo, agency contacts & photos. Clean JSON/CSV, fast overview or full detail. No account needed.

- **URL**: https://apify.com/sian.agency/neonet-property-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 overview listing extracteds

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

Learn more: https://docs.apify.com/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

## Neonet Scraper — South Korea Real Estate Data & API 🇰🇷

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![SUUMO Scraper](https://img.shields.io/badge/Store-SUUMO%20Scraper-1AE392)](https://apify.com/sian.agency/suumo-property-scraper?fpr=sian) [![at home Scraper](https://img.shields.io/badge/Store-at%20home%20Scraper-1AE392)](https://apify.com/sian.agency/athome-property-scraper?fpr=sian) [![Immobiliare.it Scraper](https://img.shields.io/badge/Store-Immobiliare.it%20Scraper-1AE392)](https://apify.com/sian.agency/immobiliare-property-scraper?fpr=sian)

#### 🎉 Turn a long-running Korean property portal into clean, structured data — priced, geo-located, ready for analysis
##### For real-estate analysts, investors, relocation agents, and data teams working the South Korea market

---

### 📋 Overview

**Need South Korea property listings as clean data instead of clicking through a legacy portal?** This scraper turns neonet.co.kr (부동산뱅크 / Real Estate Bank) search results into structured JSON/CSV — sale, jeonse (전세) and monthly-rent (월세) listings with the data buyers actually need: **price in KRW**, exclusive/supply floor area, floor, rooms, full address, **latitude/longitude geo**, **agency contact details**, and the complete photo set.

**Why analysts and agencies choose us:**
- ✅ **One clean row per listing** — contract type, complex name, area, floor, price and agency in a tidy record
- ⚡ **Fast & lightweight** — direct extraction, no slow headless browser, no proxy overhead
- 🗺️ **GPS coordinates included** — real latitude/longitude on every detail listing — map and cluster instantly
- 📞 **Agency contacts** — agency name, code and phone — built-in lead data
- 🎯 **35+ data points** — price (KRW), raw 만원 text, supply/exclusive area, floor, rooms, baths, direction, address, dates, parking, management fee, photos
- 💰 **Pay-per-result** — only pay for listings you actually receive — transparent and cheap
- 💎 **Two depths** — fast *overview* for whole-market sweeps, full *detail* for the complete attribute page
- ✨ **Three ways in** — by region code, by pasted search URL (keeps every filter), or by listing URL

---

### ✨ Features

- 🏢 **Sale, jeonse & monthly rent** — apartments (아파트) and villas (빌라/연립), all contract types
- 💰 **Money normalised** — `65,000` 만원 becomes `650000000` KRW *and* keeps the original string
- 📐 **Price-per-m² built in** — comparison and valuation math ready out of the box
- 🗺️ **Geo lat/long** — every detail listing carries real coordinates for mapping
- 🚪 **Unit specs** — rooms, baths, floor / total floors, orientation, exclusive & supply area
- 📞 **Agency block** — agency name, agency code and phone for direct outreach
- 🗓️ **Key dates** — verification date, building approval date, move-in date, contract period
- 🔎 **Detail enrichment** — full address, management fee, parking, the complete image set
- 🔗 **Paste-a-URL mode** — apply filters on the site, paste the link, every filter is preserved
- 📦 **Clean exports** — JSON, CSV, Excel straight from the dataset

---

### 🎬 Quick Start

Pick a mode, give it a region code or a search URL, and run. Listings stream into your dataset as clean rows. Export as JSON, CSV, or Excel.

```bash
curl -X POST https://api.apify.com/v2/acts/sian.agency~neonet-property-scraper/runs?token=YOUR_TOKEN \
-H 'Content-Type: application/json' \
-d '{"scrapeMode": "overview", "searchMode": "byRegion", "regionCodes": ["1168000000"], "propertyType": "AT"}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose your input

Enter a region code (e.g. `1168000000` = 서울 강남구), paste a neonet search URL, or list specific listing URLs.

#### Step 2: Pick depth

`overview` for fast whole-market listing rows, or `detail` for the full attribute page (geo, rooms, address, agency, photos).

#### Step 3: Run & export

Run the actor. Results stream into the dataset — download as JSON, CSV, or Excel, or pull them via the Apify API.

***

### 🧭 Input Options

| Field | What it does |
|---|---|
| **Scrape mode** | `overview` (fast listing rows) or `detail` (full attribute page) |
| **Search mode** | `byRegion`, `bySearchUrl`, or `byListingUrl` (detail only) |
| **Property type** | `AT` (apartment) or `VG` (villa / low-rise) |
| **Region codes** | One or more Korean 10-digit admin codes (e.g. `1168000000`) |
| **Search URLs** | Paste neonet OfferingsList.neo URLs — filters preserved |
| **Listing URLs** | Specific neonet detail URLs or offering IDs (detail mode) |
| **Max results** | Cap per run — FREE: 25 · PAID: unlimited |
| **Min / Max price** | Price band in 만원 (man-won) |

***

### 📊 Output Data

Every listing is one clean record. Key fields:

| Field | Description |
|---|---|
| `id` | neonet offering ID |
| `url` | Canonical listing URL |
| `contract_type` | 매매 (sale) / 전세 (jeonse) / 월세 (monthly) |
| `propertyTitle` | Complex / listing name |
| `price` | Price in KRW (만원 × 10,000) |
| `price_per_sqm_krw` | Computed price per square metre |
| `area_exclusive` / `area_supply` | Floor area in m² |
| `floor` / `floor_total` | Listing floor / total building floors |
| `rooms` / `baths` | Room and bathroom counts (detail) |
| `direction` | Orientation, e.g. 남향 (south-facing) |
| `address` | Full address (detail) |
| `latitude` / `longitude` | Map coordinates (detail) |
| `agency_name` / `agency_phone` | Listing agency and phone |
| `images` / `image_count` | Listing photos |
| `confirm_date` / `movein_date` | Verification & move-in dates |

Plus `mgmt_fee`, `parking`, `building_use`, `approval_date`, `contract_period`, `description`, and run `metadata`.

***

### 💰 Pricing

**Pay-per-result** — you pay only for what you receive, no monthly subscription:

- **OverviewListingExtracted** — charged per listing row from the fast overview path (the primary, cheapest event)
- **DetailListingExtracted** — charged per fully enriched listing from the detail path
- **Actor start** — a small one-time fee per run

**FREE users** can pull up to 25 listings per run to evaluate the data. **PAID users** get unlimited results. See the live per-event prices on the actor's pricing tab.

***

### ❓ FAQ

**Do I need an account or API key for neonet?**
No. The actor talks to the public site directly — no login, no key.

**Which regions are supported?**
Anywhere on neonet.co.kr. Use a leaf district code (e.g. `1168000000`) for full results, or paste a search URL straight from the site.

**Overview vs detail — which should I use?**
Start with `overview` for fast, cheap whole-market sweeps. Use `detail` when you need geo coordinates, rooms/baths, the full address, management fee, parking and the complete photo set — detail merges the overview row + detail page into one record.

**What currency are prices in?**
Korean won (KRW). The raw 만원 figure is preserved in `price_formatted`, and `price` is the normalised integer KRW value.

**Can I filter by price or sort?**
Yes — set min/max price (in 만원), or paste a search URL with your filters and sort already applied in the neonet UI.

***

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

> **Disclaimer:** This is an independent tool and is not affiliated with, endorsed by, or sponsored by neonet.co.kr / 부동산뱅크 (Real Estate Bank). "neonet" and "부동산뱅크" and neonet.co.kr are trademarks of their respective owners. Use this actor in compliance with the source site's terms of service and all applicable laws.

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's repository
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `scrapeMode` (type: `string`):

🧭 **OVERVIEW** (cheap, primary): listing rows straight from the search results — one row per listing, with contract type, property type, complex name, supply/exclusive area, floor, price, and agency + phone.

🔎 **DETAIL** (enrich): fetches each listing's full page for rooms/baths, orientation, full address, geo lat/long, approval & move-in dates, parking, management fee and the complete photo set. Detail merges overview + detail into one record.

## `searchMode` (type: `string`):

🔀 How listings are discovered.

- **byRegion** — give one or more Korean 10-digit admin region codes (e.g. `1168000000` = 서울 강남구) with a property type.
- **bySearchUrl** — paste a ready-made neonet OfferingsList.neo search URL with your filters applied.
- **byListingUrl** — fetch specific listings directly (DETAIL only).

## `propertyType` (type: `string`):

🏢 Property type for **byRegion** searches.

- **AT** — 아파트 (apartment)
- **VG** — 빌라/연립 (villa / low-rise)

## `regionCodes` (type: `array`):

📍 **BY REGION:** Korean 10-digit administrative region codes to scrape. Use a leaf district code for full results — e.g. `1168000000` (서울 강남구), `1144000000` (서울 마포구), `2620000000` (부산 부산진구).

💡 **TIP:** For precise filtering, use **bySearchUrl** instead — apply your filters in neonet's UI and paste the URL.

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

🔗 **BY SEARCH URL:** Paste one or more neonet.co.kr `OfferingsList.neo` search-results URLs. Apply all your filters in the neonet UI first, then copy the address — region, property type and filter params are preserved.

## `listingUrls` (type: `array`):

🏠 **BY LISTING URL (DETAIL ONLY):** Paste neonet detail URLs (`OfferingsDetail.neo?offerings_cd=AT_140737646...`) or bare offering IDs. Used with scrapeMode = detail.

## `maxResults` (type: `integer`):

🔢 Maximum listings to return per run. **FREE users:** capped at 25 · **PAID users:** unlimited.

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

📄 Maximum result pages to paginate per region/search URL before stopping. Each page is one cheap list fetch.

## `minPrice` (type: `integer`):

💰 **OPTIONAL:** Minimum price filter, in 만원 (man-won). Applied to byRegion searches as the site's own `price_min` filter.

## `maxPrice` (type: `integer`):

💰 **OPTIONAL:** Maximum price filter, in 만원 (man-won). Applied to byRegion searches as the site's own `price_max` filter.

## `sortBy` (type: `string`):

↕️ **OPTIONAL:** Pass-through value for neonet's own list sort (`sort_list`). Leave empty for the site default.

## `proxyCountry` (type: `string`):

🌐 **OPTIONAL:** Route requests through a residential proxy in this 2-letter country (e.g. `KR`). **Leave empty** — neonet.co.kr is reachable without a proxy, so direct keeps runs fast and cheap. Set only if you hit a soft per-IP rate-gate at scale.

## Actor input object example

```json
{
  "scrapeMode": "overview",
  "searchMode": "byRegion",
  "propertyType": "AT",
  "regionCodes": [
    "1168000000"
  ],
  "maxResults": 100,
  "maxPages": 5
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped neonet listings as a clean JSON/CSV dataset.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("sian.agency/neonet-property-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/neonet-property-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 '{}' |
apify call sian.agency/neonet-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Neonet Scraper — South Korea Real Estate Data & API",
        "description": "neonet.co.kr (부동산뱅크) scraper & real estate data API for South Korea. Extract sale, jeonse & monthly-rent listings — price (KRW), exclusive/supply area, floor, rooms, address, lat/long geo, agency contacts & photos. Clean JSON/CSV, fast overview or full detail. No account needed.",
        "version": "1.0",
        "x-build-id": "gBPYl9TURceMSXEX6"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~neonet-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-neonet-property-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/sian.agency~neonet-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-neonet-property-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/sian.agency~neonet-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-neonet-property-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": {
                    "scrapeMode": {
                        "title": "🧭 Scrape mode",
                        "enum": [
                            "overview",
                            "detail"
                        ],
                        "type": "string",
                        "description": "🧭 **OVERVIEW** (cheap, primary): listing rows straight from the search results — one row per listing, with contract type, property type, complex name, supply/exclusive area, floor, price, and agency + phone.\n\n🔎 **DETAIL** (enrich): fetches each listing's full page for rooms/baths, orientation, full address, geo lat/long, approval & move-in dates, parking, management fee and the complete photo set. Detail merges overview + detail into one record.",
                        "default": "overview"
                    },
                    "searchMode": {
                        "title": "🔀 Search mode",
                        "enum": [
                            "byRegion",
                            "bySearchUrl",
                            "byListingUrl"
                        ],
                        "type": "string",
                        "description": "🔀 How listings are discovered.\n\n- **byRegion** — give one or more Korean 10-digit admin region codes (e.g. `1168000000` = 서울 강남구) with a property type.\n- **bySearchUrl** — paste a ready-made neonet OfferingsList.neo search URL with your filters applied.\n- **byListingUrl** — fetch specific listings directly (DETAIL only).",
                        "default": "byRegion"
                    },
                    "propertyType": {
                        "title": "🏢 Property type",
                        "enum": [
                            "AT",
                            "VG"
                        ],
                        "type": "string",
                        "description": "🏢 Property type for **byRegion** searches.\n\n- **AT** — 아파트 (apartment)\n- **VG** — 빌라/연립 (villa / low-rise)",
                        "default": "AT"
                    },
                    "regionCodes": {
                        "title": "📍 Region codes",
                        "type": "array",
                        "description": "📍 **BY REGION:** Korean 10-digit administrative region codes to scrape. Use a leaf district code for full results — e.g. `1168000000` (서울 강남구), `1144000000` (서울 마포구), `2620000000` (부산 부산진구).\n\n💡 **TIP:** For precise filtering, use **bySearchUrl** instead — apply your filters in neonet's UI and paste the URL.",
                        "default": [
                            "1168000000"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "🔗 Search URLs",
                        "type": "array",
                        "description": "🔗 **BY SEARCH URL:** Paste one or more neonet.co.kr `OfferingsList.neo` search-results URLs. Apply all your filters in the neonet UI first, then copy the address — region, property type and filter params are preserved.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingUrls": {
                        "title": "🏠 Listing URLs",
                        "type": "array",
                        "description": "🏠 **BY LISTING URL (DETAIL ONLY):** Paste neonet detail URLs (`OfferingsDetail.neo?offerings_cd=AT_140737646...`) or bare offering IDs. Used with scrapeMode = detail.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "🔢 Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "🔢 Maximum listings to return per run. **FREE users:** capped at 25 · **PAID users:** unlimited.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "📄 Max pages per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "📄 Maximum result pages to paginate per region/search URL before stopping. Each page is one cheap list fetch.",
                        "default": 5
                    },
                    "minPrice": {
                        "title": "💰 Min price (만원)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "💰 **OPTIONAL:** Minimum price filter, in 만원 (man-won). Applied to byRegion searches as the site's own `price_min` filter."
                    },
                    "maxPrice": {
                        "title": "💰 Max price (만원)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "💰 **OPTIONAL:** Maximum price filter, in 만원 (man-won). Applied to byRegion searches as the site's own `price_max` filter."
                    },
                    "sortBy": {
                        "title": "↕️ Sort order",
                        "type": "string",
                        "description": "↕️ **OPTIONAL:** Pass-through value for neonet's own list sort (`sort_list`). Leave empty for the site default."
                    },
                    "proxyCountry": {
                        "title": "🌐 Proxy country",
                        "type": "string",
                        "description": "🌐 **OPTIONAL:** Route requests through a residential proxy in this 2-letter country (e.g. `KR`). **Leave empty** — neonet.co.kr is reachable without a proxy, so direct keeps runs fast and cheap. Set only if you hit a soft per-IP rate-gate at scale."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
