# SUUMO Scraper - Japan Real Estate Listings API (`lentic_clockss/suumo-property-scraper`) Actor

Scrape SUUMO.jp Japan property listings: used & new condos, houses, land, and rentals. Extract prices, layouts, area, station access, fees, and photos as a SUUMO API alternative.

- **URL**: https://apify.com/lentic\_clockss/suumo-property-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### What does SUUMO Scraper do?

**SUUMO Scraper** is a Japan real estate scraper for [SUUMO.jp](https://suumo.jp/) — the leading Japanese property portal. It extracts **used and new condominiums** (*中古・新築マンション*), **houses** (*一戸建て*), **land** (*土地*), and **rentals** (*賃貸*) from Tokyo, Osaka, and other prefectures.

Paste a SUUMO search or detail URL, or set a location path such as `tokyo/sc_shinjuku` with a `propertyType`, then download structured listings as **JSON, CSV, Excel, or HTML**.

This Actor works as a practical **SUUMO API alternative**: it reads public search (SRP) and detail (LDP) HTML over lightweight HTTP, so you get prices, floor plans, land/building area, station access, fees, and photos without maintaining your own browser stack.

### What can this SUUMO scraper extract?

| Data point | Description |
|---|---|
| Listing ID & URL | Stable SUUMO `nc_` / `bc_` / `jnc_` ID and canonical link |
| Property category | `chuko_mansion`, `shinchiku_mansion`, `ikkodate`, `chukoikkodate`, `tochi`, `chintai` |
| Channel | `BUY` (sale) or `RENT` (賃貸) |
| Title & building | Headline and building name (*物件名*) |
| Price | Sale or rent text + normalized JPY (`億` / `万`); ranges expose `priceMin` / `priceMax` |
| Layout & area | Floor plan (*間取り*); exclusive / land / building area m² (layout+area strings are split) |
| Location & access | Address (*所在地*), rail/station (*沿線・駅*) |
| Building | Built year/month, floor, structure when available |
| Rent fees | Admin fee (*管理費*), deposit (*敷金*), key money (*礼金*) |
| Media & agent | Photo URLs; public inquiry/agent block on detail pages |

#### SUUMO property types covered

| propertyType | Japanese | Path |
|---|---|---|
| `chuko_mansion` | 中古マンション (used condo) | `/ms/chuko/` |
| `shinchiku_mansion` | 新築マンション (new condo) | `/ms/shinchiku/` |
| `ikkodate` | 新築一戸建て (new house) | `/ikkodate/` |
| `chukoikkodate` | 中古一戸建て (used house) | `/chukoikkodate/` |
| `tochi` | 土地 (land) | `/tochi/` |
| `chintai` | 賃貸 (rent) | `/chintai/` |

### Why scrape SUUMO.jp?

- **Japan market research** — track asking prices and inventory for Tokyo, Osaka, and other cities  
- **Investment & proptech** — feed CRM, pricing models, or dashboards with fresh sale and rent data  
- **Lead generation** — collect publicly shown agency contact blocks from listing detail pages  
- **Competitive monitoring** — watch new condo launches, house supply, and rental listings without manual browsing  
- **Data export** — pull SUUMO property data into Sheets, warehouses, or your own API  

### How to scrape SUUMO

1. Open **SUUMO Scraper** in Apify Console.  
2. Set **location** (e.g. `tokyo/sc_shinjuku`) and **propertyType**, *or* paste SUUMO **start URLs** (category is auto-detected).  
3. Choose **max listings** / **max pages** and whether to open **detail pages**.  
4. Proxy is optional — direct HTTP works for typical SUUMO runs; enable Apify **RESIDENTIAL + JP** if you need IP diversity.  
5. Click **Start**, then export results from the **Dataset** tab.

#### Example input — scrape SUUMO used condos in Shinjuku

```json
{
  "location": "tokyo/sc_shinjuku",
  "propertyType": "chuko_mansion",
  "maxItems": 20,
  "maxPages": 1,
  "scrapeDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Example input — scrape SUUMO rentals by URL

```json
{
  "startUrls": [
    { "url": "https://suumo.jp/chintai/tokyo/sc_shinjuku/" }
  ],
  "maxItems": 15,
  "maxPages": 1,
  "scrapeDetails": true
}
```

#### Supported SUUMO URL patterns

- Used condo: `https://suumo.jp/ms/chuko/tokyo/sc_shinjuku/`
- New condo: `https://suumo.jp/ms/shinchiku/tokyo/sc_shinjuku/`
- New house: `https://suumo.jp/ikkodate/tokyo/sc_shinjuku/`
- Used house: `https://suumo.jp/chukoikkodate/tokyo/sc_shinjuku/`
- Land: `https://suumo.jp/tochi/tokyo/sc_shinjuku/`
- Rent: `https://suumo.jp/chintai/tokyo/sc_shinjuku/`
- Detail examples: `/nc_{id}/`, `/bc_{id}/`, `/jnc_{id}/`
- Pagination: `?page=2` (and higher)

### How much does it cost to scrape SUUMO?

This Actor uses **Pay per event** pricing. You pay for:

| Event | Price |
|---|---|
| **Actor Start** (`apify-actor-start`) | **$0.005** per start (scaled by run memory: one event per GB, minimum one) |
| **result** (`apify-default-dataset-item`) | **$2.50 / 1,000** results (**$0.0025** per SUUMO listing) |

**Platform usage** (compute, proxy if enabled, etc.) is **also billed to the user** on top of event charges.

Example (illustrative): 1 start + 1,000 listings ≈ **$0.005 + $2.50** in event fees, plus platform usage for the run.

Tip: set a **max total charge** on the run if you want a hard spending cap. Start with `maxItems` 10–50 while testing field coverage.

### Input

Open the **Input** tab for the full schema. Main fields:

| Field | Purpose |
|---|---|
| `startUrls` | SUUMO search or detail URLs (auto-detect `propertyType`) |
| `location` | Area path such as `tokyo/sc_shinjuku` |
| `propertyType` | One of the six SUUMO categories |
| `channel` | Legacy alias: `BUY`→`chuko_mansion`, `RENT`→`chintai` |
| `maxItems` / `maxPages` | Caps (`?page=N` pagination) |
| `scrapeDetails` | Enrich each card from the detail page |
| `requestDelayMillis` | Politeness delay between requests |
| `maxConcurrency` | Concurrent detail fetches |
| `proxyConfiguration` | Optional Apify proxy (JP residential if used) |

### Output example

You can download the dataset extracted by SUUMO Scraper in JSON, HTML, CSV, or Excel.

```json
{
  "id": "21278073",
  "url": "https://suumo.jp/ms/chuko/tokyo/sc_shinjuku/nc_21278073/",
  "source": "suumo",
  "sourceLayer": "srp+ldp",
  "propertyType": "chuko_mansion",
  "channel": "BUY",
  "title": "ストークマンション落合 2880万円（1LDK）",
  "buildingName": "ストークマンション落合",
  "price": "2880万円",
  "priceAmount": 28800000,
  "currency": "JPY",
  "floorPlan": "1LDK",
  "exclusiveAreaSqm": 42.8,
  "address": "東京都新宿区上落合２",
  "access": "東京メトロ東西線「落合」歩6分",
  "builtYearMonth": "1969年11月",
  "scrapedAt": "2026-07-18T10:00:00.000Z"
}
```

### Is it legal to scrape SUUMO?

Our scrapers are ethical and do not extract private user data that is not shown on public listing pages. They only extract what SUUMO has chosen to display publicly. You should still comply with SUUMO terms, applicable laws (including Japan’s APPI and GDPR where personal data appears), and only scrape when you have a legitimate purpose. If unsure, consult your lawyers.

### FAQ

#### How do I scrape SUUMO for sale listings in Tokyo?

Set `location` to a Tokyo area path (e.g. `tokyo/sc_shinjuku`) and choose a sale `propertyType` such as `chuko_mansion`, `ikkodate`, or `tochi`. Or paste a `/ms/chuko/`, `/ikkodate/`, or `/tochi/` search URL.

#### How do I scrape SUUMO rentals (賃貸)?

Set `propertyType` to `chintai`, or use a URL under `https://suumo.jp/chintai/`.

#### How do I scrape SUUMO new condominiums (新築マンション)?

Set `propertyType` to `shinchiku_mansion` or open a `/ms/shinchiku/` search URL.

#### How do I scrape SUUMO land (土地) listings?

Set `propertyType` to `tochi` or use a `/tochi/` URL. Land records include `landArea` / `landAreaSqm` when present.

#### Do I need a SUUMO API key?

No. This Actor scrapes the public SUUMO website and returns structured property data — useful when you need a **SUUMO data API** without an official partnership.

#### Can I export SUUMO listings to Google Sheets or Excel?

Yes. Download the Dataset as Excel/CSV, or use Apify **integrations** and the Dataset API to push results into Sheets, webhooks, or your backend.

#### What location format should I use for SUUMO scraping?

Use SUUMO path segments such as `tokyo/sc_shinjuku` (prefecture + city slug). You can also paste a full search URL in `startUrls` and skip `location`.

#### What if a SUUMO scrape returns zero results?

Check that the location/URL is valid for that category, try with or without proxy, and inspect Key-Value Store records `ERROR_SUMMARY` / `OUTPUT` for fetch or parse issues.

### Tips for better SUUMO scraping

- Prefer **`propertyType`** over legacy `channel`.
- Enable **`scrapeDetails`** when you need admin fees, orientation, agent text, or richer galleries.
- Sale categories and rent use **different page templates** — keep type and URL consistent.
- Use a polite **`requestDelayMillis`** (e.g. 600–1200) for larger crawls.
- Start with small `maxItems` to validate fields and cost before scaling.

### Support

Questions or feature requests? Open an issue on the Actor page or contact the developer through Apify. Feedback on other prefectures, filters, or export formats is welcome.

# Actor input Schema

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

SUUMO search (SRP) or listing detail (LDP) URLs. Search URLs auto-detect propertyType and override location/propertyType when provided.

## `location` (type: `string`):

SUUMO area path like tokyo/sc\_shinjuku (prefecture/city). Used when building a search from location + propertyType.

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

SUUMO listing category. Used when building a search from location. Ignored when startUrls contain a search URL (auto-detected).

## `channel` (type: `string`):

Legacy alias: BUY → chuko\_mansion, RENT → chintai. Prefer propertyType. If propertyType is left at the default (chuko\_mansion) and channel=RENT, RENT wins.

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

Maximum property records to save.

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

Maximum SRP pages to fetch (?page=N).

## `scrapeDetails` (type: `boolean`):

Fetch each listing LDP and enrich with overview table fields.

## `requestDelayMillis` (type: `integer`):

Politeness delay between HTTP requests.

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

Max concurrent HTTP fetches for detail pages.

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

Optional. Direct HTTP works for SUUMO in research; enable Apify RESIDENTIAL + JP if you need IP diversity.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://suumo.jp/ms/chuko/tokyo/sc_shinjuku/"
    }
  ],
  "location": "tokyo/sc_shinjuku",
  "propertyType": "chuko_mansion",
  "channel": "BUY",
  "maxItems": 25,
  "maxPages": 1,
  "scrapeDetails": true,
  "requestDelayMillis": 800,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Normalized SUUMO listing records from SRP and optional LDP enrichment.

## `runSummary` (type: `string`):

Counts, engine, and timestamps for the run.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://suumo.jp/ms/chuko/tokyo/sc_shinjuku/"
        }
    ],
    "location": "tokyo/sc_shinjuku"
};

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

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/suumo-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 '{
  "startUrls": [
    {
      "url": "https://suumo.jp/ms/chuko/tokyo/sc_shinjuku/"
    }
  ],
  "location": "tokyo/sc_shinjuku"
}' |
apify call lentic_clockss/suumo-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SUUMO Scraper - Japan Real Estate Listings API",
        "description": "Scrape SUUMO.jp Japan property listings: used & new condos, houses, land, and rentals. Extract prices, layouts, area, station access, fees, and photos as a SUUMO API alternative.",
        "version": "0.1",
        "x-build-id": "qUiMcuOvc2AvHXQAN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~suumo-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-suumo-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/lentic_clockss~suumo-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-suumo-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/lentic_clockss~suumo-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-suumo-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "SUUMO search (SRP) or listing detail (LDP) URLs. Search URLs auto-detect propertyType and override location/propertyType when provided.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "location": {
                        "title": "Location path",
                        "type": "string",
                        "description": "SUUMO area path like tokyo/sc_shinjuku (prefecture/city). Used when building a search from location + propertyType.",
                        "default": "tokyo/sc_shinjuku"
                    },
                    "propertyType": {
                        "title": "Property type",
                        "enum": [
                            "chuko_mansion",
                            "shinchiku_mansion",
                            "ikkodate",
                            "chukoikkodate",
                            "tochi",
                            "chintai"
                        ],
                        "type": "string",
                        "description": "SUUMO listing category. Used when building a search from location. Ignored when startUrls contain a search URL (auto-detected).",
                        "default": "chuko_mansion"
                    },
                    "channel": {
                        "title": "Channel (legacy)",
                        "enum": [
                            "BUY",
                            "RENT"
                        ],
                        "type": "string",
                        "description": "Legacy alias: BUY → chuko_mansion, RENT → chintai. Prefer propertyType. If propertyType is left at the default (chuko_mansion) and channel=RENT, RENT wins.",
                        "default": "BUY"
                    },
                    "maxItems": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum property records to save.",
                        "default": 25
                    },
                    "maxPages": {
                        "title": "Max search pages",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum SRP pages to fetch (?page=N).",
                        "default": 1
                    },
                    "scrapeDetails": {
                        "title": "Scrape detail pages",
                        "type": "boolean",
                        "description": "Fetch each listing LDP and enrich with overview table fields.",
                        "default": true
                    },
                    "requestDelayMillis": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "maximum": 15000,
                        "type": "integer",
                        "description": "Politeness delay between HTTP requests.",
                        "default": 800
                    },
                    "maxConcurrency": {
                        "title": "Request concurrency",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Max concurrent HTTP fetches for detail pages.",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional. Direct HTTP works for SUUMO in research; enable Apify RESIDENTIAL + JP if you need IP diversity.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```