# SUUMO Japan Real Estate Scraper (`solidcode/suumo-jp-scraper`) Actor

\[💰 $0.70 / 1K] Extract property listings from SUUMO (suumo.jp), Japan's largest real-estate portal. Get rent or sale prices, fees, deposit, key money, floor plan, area, station access, photos, and agency contacts. Search by prefecture and type, or paste any SUUMO URL.

- **URL**: https://apify.com/solidcode/suumo-jp-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## SUUMO Japan Real Estate Scraper

Pull rental and for-sale property listings from SUUMO (suumo.jp), Japan's largest real-estate portal — yen-normalized prices, deposit/key-money/management-fee breakdowns, floor plans, station walk-times, building specs, photos, and agency phone numbers across all 47 prefectures. Built for property investors, relocation and expat-housing agents, and market researchers tracking the Japanese housing market who need clean, structured listings without manually combing through SUUMO's Japanese-only interface one ward at a time.

### Why This Scraper?

- **All 47 prefectures, ward-level granularity** — from Hokkaido (北海道) to Okinawa (沖縄県), or pick "All Japan" and let it sweep the major markets first. Searches drill down to individual wards (区), not just prefecture landing pages.
- **Rent and for-sale in one actor** — collect rentals (賃貸) or properties for sale (購入) by flipping a single dropdown. No separate run, no separate setup.
- **Six property categories** — rental apartments/mansions (賃貸マンション・アパート), used condos (中古マンション), new condos (新築マンション), used houses (中古一戸建て), new houses (新築一戸建て), and land (土地).
- **Full Japanese rental-cost breakdown** — separate fields for deposit (敷金), key money (礼金), and monthly management fee (管理費), not just headline rent. Composite values like `1万450円` are parsed to exact yen.
- **万円 prices normalized to integer JPY** — every listing returns both the raw SUUMO display string (e.g. `8.5万円`) and a clean numeric `price` in yen, ready for sorting and analysis.
- **Station access with walk-times** — each listing carries train line, station name, and walking minutes (歩N分) as structured fields, so you can filter by commute.
- **Per-listing detail enrichment** — turn on Full Listing Details to open each property and capture all photos, amenities and conditions (設備・条件), agency name and phone, exact address (所在地), and building specs (structure, floor, build year).
- **Paste-any-SUUMO-URL power mode** — drop in any search-results, category, ward, or individual listing URL and the scraper preserves the filters already baked into it (price, area, layout, sort).

### Use Cases

**Real Estate Investment & Analysis**
- Compare asking prices in yen per square metre across wards and prefectures
- Track new-condo (新築マンション) supply in growth corridors like Tokyo and Osaka
- Build for-sale comps for used condos and houses before underwriting
- Monitor land (土地) listings and price-per-area in target districts

**Relocation & Expat Housing**
- Surface English-friendly structured rental data from a Japanese-only portal
- Shortlist apartments by layout, area, and station walk-time for incoming hires
- Capture deposit and key-money totals up front so tenants budget the full move-in cost
- Compare neighborhoods by commute using station-access walk-times

**Market Research**
- Map rental inventory and median rent by ward across all 47 prefectures
- Track management-fee and key-money norms by region
- Compare new vs. used condo pricing in the same district
- Measure listing freshness with per-listing published dates

**Lead Generation for Agencies**
- Build agency contact lists with agency name and phone from detail pages
- Identify which brokerages dominate a given ward
- Feed fresh listings into a CRM with deduplicated property IDs

**Price Monitoring**
- Re-run saved searches to watch rent and sale prices move over time
- Alert on new listings entering a target prefecture or property type
- Track inventory volume as a demand signal

### Getting Started

#### Simple Rent Search

The quickest way to start — rentals in Tokyo with defaults:

```json
{
    "transactionType": "rent",
    "prefecture": "tokyo",
    "maxResults": 50
}
````

#### Buy a Used Condo with Full Details

Switch to for-sale, pick a property type, and enrich every listing:

```json
{
    "transactionType": "buy",
    "propertyType": "used-condo",
    "prefecture": "osaka",
    "includeDetails": true,
    "maxResults": 200
}
```

#### Power User — Paste a SUUMO URL

Already built a filtered search in your browser? Paste the URL and keep its filters:

```json
{
    "startUrls": [
        "https://suumo.jp/chintai/tokyo/sc_shinjuku/"
    ],
    "includeDetails": true,
    "maxResults": 500
}
```

### Input Reference

#### What to Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `transactionType` | string | `"rent"` | `"rent"` for rentals (賃貸) or `"buy"` for properties for sale (購入). Ignored when Start URLs are provided. |
| `propertyType` | string | `"any"` | Property category: `any`, `apartment` (rental apartment/mansion), `used-condo`, `new-condo`, `house` (used house), `new-house`, or `land`. Ignored when Start URLs are provided. |
| `prefecture` | string | `"tokyo"` | One of the 47 prefectures (e.g. `tokyo`, `osaka`, `hokkaido`, `okinawa`) or `all` for All Japan. Ignored when Start URLs are provided. |

#### Advanced & Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | `[]` | Paste exact suumo.jp URLs — search, category, ward, or individual listing pages. Overrides the three search fields above and preserves any filters already in the URL. |
| `maxResults` | integer | `100` | Maximum listings to collect across all searches and URLs combined. `0` means unlimited. Results come in full pages, so the final page may slightly overshoot. |
| `includeDetails` | boolean | `true` | Open each listing's detail page to capture all photos, amenities, agency phone, exact address, and building specs. Slower but much richer. When off, only result-page fields are returned. |

### Output

Each listing is returned as one flat row with structured arrays for station access, features, and images. Example (rental, fully enriched):

```json
{
    "url": "https://suumo.jp/chintai/jnc_000012345678/",
    "listingId": "jnc_000012345678",
    "title": "サンプルマンション新宿",
    "transactionType": "rent",
    "propertyType": "apartment",
    "price": 185000,
    "priceText": "18.5万円",
    "currency": "JPY",
    "managementFee": 8000,
    "deposit": "1ヶ月",
    "keyMoney": "1ヶ月",
    "layout": "1LDK",
    "areaSqm": 42.5,
    "floor": "5階／10階建",
    "buildingAge": "2019年3月",
    "structure": "RC造",
    "address": "東京都新宿区西新宿",
    "stationAccess": [
        { "line": "JR山手線", "station": "新宿", "walkMinutes": 8 }
    ],
    "features": ["バス・トイレ別", "エアコン", "オートロック"],
    "images": ["https://img01.suumo.com/front/gazo/example.jpg"],
    "agencyName": "サンプル不動産株式会社",
    "agencyPhone": "0120-000-000",
    "agencyLicense": "東京都知事(3)第00000号",
    "agencyUrl": null,
    "publishedAt": "2026年6月20日",
    "scrapedAt": "2026-06-26T09:00:00+00:00"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Canonical SUUMO URL of the listing |
| `listingId` | string | Unique property identifier (used for deduplication) |
| `title` | string | Building or property name |
| `transactionType` | string | `"rent"` or `"buy"` |
| `propertyType` | string | Resolved category (e.g. `apartment`, `used-condo`, `land`) |
| `publishedAt` | string | Listing's information-update date (情報更新日) |
| `scrapedAt` | string | ISO 8601 timestamp of collection |

#### Pricing

| Field | Type | Description |
|-------|------|-------------|
| `price` | number | Price in integer Japanese yen (rent per month, or sale price) |
| `priceText` | string | Raw SUUMO display string (e.g. `18.5万円`) |
| `currency` | string | Always `"JPY"` |
| `managementFee` | number | Monthly management/common fee (管理費・共益費) in yen |
| `deposit` | string | Deposit (敷金 / 保証金) — rentals only |
| `keyMoney` | string | Key money (礼金) — rentals only |

#### Layout & Building Specs

| Field | Type | Description |
|-------|------|-------------|
| `layout` | string | Floor plan code (間取り), e.g. `1LDK`, `3DK` |
| `areaSqm` | number | Floor or land area in square metres (専有面積 / 土地面積) |
| `floor` | string | Floor and total floors (所在階／階建) |
| `buildingAge` | string | Build year/month (築年月) or completion date |
| `structure` | string | Construction type (構造), e.g. `RC造`, `木造` |

#### Location & Station Access

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Property address (所在地) |
| `stationAccess` | array | List of `{ line, station, walkMinutes }` objects — train line, station name, and walking minutes, up to 6 nearby stations |

#### Agency & Media

| Field | Type | Description |
|-------|------|-------------|
| `agencyName` | string | Listing agency name |
| `agencyPhone` | string | Agency phone number (detail pages only) |
| `agencyLicense` | string | Real-estate license number (免許番号) |
| `agencyUrl` | string | Agency website, when available |
| `features` | array | Amenities and conditions (設備・条件), up to 30 |
| `images` | array | Listing photo URLs (up to 40 on detail pages) |

### Tips for Best Results

- **Start small to test.** Set `maxResults` to 20–50 on your first run to confirm the prefecture and property type are right, then scale up.
- **Paste a filtered SUUMO URL for precise control.** Build your search in the browser with price, area, and layout filters applied, then drop the results URL into `startUrls` — every filter is preserved, far beyond what the guided fields expose.
- **Turn on Full Listing Details for contact and photo data.** Agency phone, exact address, full amenity lists, and most photos live only on each listing's detail page. With details off you get the faster result-page fields only.
- **Remember prices are in 万円.** SUUMO displays prices in units of 10,000 yen, so `8.5万円` is ¥85,000 — the actor gives you both the raw `priceText` and a clean integer `price` in yen.
- **Budget the full move-in cost for rentals.** Use `deposit` (敷金) and `keyMoney` (礼金) alongside monthly rent and `managementFee` — Japanese rentals often require several months' rent up front.
- **Use "All Japan" for nationwide sweeps.** Setting `prefecture` to `all` covers the whole country, starting with the largest markets so a small `maxResults` is filled quickly.
- **Filter by commute using station walk-times.** Each `stationAccess` entry includes `walkMinutes`, so you can shortlist listings within a target walking distance of a station.

### Pricing

**From $0.70 per 1,000 results** — flat, predictable Pay-Per-Result pricing with no surprises. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.08 | $0.08 | $0.07 | $0.07 |
| 1,000 | $0.84 | $0.79 | $0.74 | $0.70 |
| 10,000 | $8.40 | $7.90 | $7.40 | $7.00 |
| 100,000 | $84.00 | $79.00 | $74.00 | $70.00 |

A "result" is one property listing returned to your dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is intended for lawful data collection of publicly available property listings. Use it responsibly and in compliance with SUUMO's terms of service and applicable laws, including data-protection regulations. Collected data — particularly agency contact details — should be handled in accordance with privacy rules such as Japan's Act on the Protection of Personal Information (APPI) and the GDPR where relevant. You are responsible for how you use the data you collect; do not use it for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `transactionType` (type: `string`):

Collect rental listings (賃貸) or properties for sale (購入). Ignored when Start URLs are provided.

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

Property category to search. Choose 'Any' to include all available types. Ignored when Start URLs are provided.

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

Prefecture (都道府県) to search. Choose 'All Japan' to search the whole country. Ignored when Start URLs are provided.

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

Power-user input. Paste SUUMO (suumo.jp) URLs directly — search-result pages, category or borough pages, or individual listing pages. When provided, these override the Rent/Buy, Property Type, and Prefecture settings above, and any filters already in the URL (price, area, layout, sort) are preserved.

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

Maximum number of listings to collect across all searches and URLs combined. Set to 0 for unlimited. Results are collected in full pages, so the final page may overshoot this cap by a few listings. Tip: start with 20-50 to test, then increase.

## `includeDetails` (type: `boolean`):

Open each listing's detail page to capture the full record — all photos, amenities, agency name and phone, exact address, and building specs (structure, floor, build year). Slower but much richer. When off, only the fields shown on result pages are returned.

## Actor input object example

```json
{
  "transactionType": "rent",
  "propertyType": "any",
  "prefecture": "tokyo",
  "startUrls": [],
  "maxResults": 100,
  "includeDetails": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of scraped SUUMO listings with key fields.

# 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 = {
    "transactionType": "rent",
    "propertyType": "any",
    "prefecture": "tokyo",
    "startUrls": [],
    "maxResults": 100,
    "includeDetails": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/suumo-jp-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 = {
    "transactionType": "rent",
    "propertyType": "any",
    "prefecture": "tokyo",
    "startUrls": [],
    "maxResults": 100,
    "includeDetails": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/suumo-jp-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 '{
  "transactionType": "rent",
  "propertyType": "any",
  "prefecture": "tokyo",
  "startUrls": [],
  "maxResults": 100,
  "includeDetails": true
}' |
apify call solidcode/suumo-jp-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SUUMO Japan Real Estate Scraper",
        "description": "[💰 $0.70 / 1K] Extract property listings from SUUMO (suumo.jp), Japan's largest real-estate portal. Get rent or sale prices, fees, deposit, key money, floor plan, area, station access, photos, and agency contacts. Search by prefecture and type, or paste any SUUMO URL.",
        "version": "1.0",
        "x-build-id": "7Bcnq9ed0F05DoFRs"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~suumo-jp-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-suumo-jp-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/solidcode~suumo-jp-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-suumo-jp-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/solidcode~suumo-jp-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-suumo-jp-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": {
                    "transactionType": {
                        "title": "Rent or Buy",
                        "enum": [
                            "rent",
                            "buy"
                        ],
                        "type": "string",
                        "description": "Collect rental listings (賃貸) or properties for sale (購入). Ignored when Start URLs are provided.",
                        "default": "rent"
                    },
                    "propertyType": {
                        "title": "Property Type",
                        "enum": [
                            "any",
                            "apartment",
                            "used-condo",
                            "new-condo",
                            "house",
                            "new-house",
                            "land"
                        ],
                        "type": "string",
                        "description": "Property category to search. Choose 'Any' to include all available types. Ignored when Start URLs are provided.",
                        "default": "any"
                    },
                    "prefecture": {
                        "title": "Prefecture",
                        "enum": [
                            "all",
                            "hokkaido",
                            "aomori",
                            "iwate",
                            "miyagi",
                            "akita",
                            "yamagata",
                            "fukushima",
                            "ibaraki",
                            "tochigi",
                            "gunma",
                            "saitama",
                            "chiba",
                            "tokyo",
                            "kanagawa",
                            "niigata",
                            "toyama",
                            "ishikawa",
                            "fukui",
                            "yamanashi",
                            "nagano",
                            "gifu",
                            "shizuoka",
                            "aichi",
                            "mie",
                            "shiga",
                            "kyoto",
                            "osaka",
                            "hyogo",
                            "nara",
                            "wakayama",
                            "tottori",
                            "shimane",
                            "okayama",
                            "hiroshima",
                            "yamaguchi",
                            "tokushima",
                            "kagawa",
                            "ehime",
                            "kochi",
                            "fukuoka",
                            "saga",
                            "nagasaki",
                            "kumamoto",
                            "oita",
                            "miyazaki",
                            "kagoshima",
                            "okinawa"
                        ],
                        "type": "string",
                        "description": "Prefecture (都道府県) to search. Choose 'All Japan' to search the whole country. Ignored when Start URLs are provided.",
                        "default": "tokyo"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Power-user input. Paste SUUMO (suumo.jp) URLs directly — search-result pages, category or borough pages, or individual listing pages. When provided, these override the Rent/Buy, Property Type, and Prefecture settings above, and any filters already in the URL (price, area, layout, sort) are preserved.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to collect across all searches and URLs combined. Set to 0 for unlimited. Results are collected in full pages, so the final page may overshoot this cap by a few listings. Tip: start with 20-50 to test, then increase.",
                        "default": 100
                    },
                    "includeDetails": {
                        "title": "Include Full Listing Details",
                        "type": "boolean",
                        "description": "Open each listing's detail page to capture the full record — all photos, amenities, agency name and phone, exact address, and building specs (structure, floor, build year). Slower but much richer. When off, only the fields shown on result pages are returned.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
