# Airbnb Host Portfolio Scraper (`automation-lab/airbnb-host-portfolio-scraper`) Actor

🏠 Map public Airbnb host profiles to surfaced managed listings. Export host details, reported portfolio size, property types, ratings, reviews, images, and canonical URLs.

- **URL**: https://apify.com/automation-lab/airbnb-host-portfolio-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Airbnb Host Portfolio Scraper

Turn public Airbnb host profiles into structured host-to-listing portfolio data.

Paste Airbnb host profile URLs or numeric host IDs. The Actor returns one export-ready row for every managed listing that Airbnb publicly surfaces, enriched with host identity, portfolio size, property attributes, ratings, reviews, and images.

> **Coverage note:** Airbnb currently surfaces up to 10 managed listings on a public host profile. This Actor reports that visible subset honestly. When Airbnb exposes a larger total count, `isPortfolioTruncated` tells you that more inventory exists but is not public on the profile.

### What does Airbnb Host Portfolio Scraper do?

Airbnb Host Portfolio Scraper maps a public host profile to its visible property portfolio.

It extracts:

- 🧑 Host ID, display name, location, bio, and profile image
- ⭐ Superhost, identity badge, profile, and home-host flags
- 🗓️ Hosting experience and public verification types
- 🏘️ Total managed listing count reported by Airbnb
- 🔎 Number of listing records surfaced on the public profile
- 🏠 Listing ID, canonical URL, name, property type, and room type
- 🛏️ Bedrooms, bathrooms, and beds when available
- ⚡ Instant-book, luxury, new-listing, and Superhost flags
- 📊 Rating average and review count
- 🖼️ Listing image and thumbnail URLs

Results are available as JSON, CSV, Excel, XML, RSS, or through the Apify API.

### Who is it for?

#### Short-term rental analysts

Build repeatable samples of professional operators and compare reported portfolio sizes with publicly promoted inventory.

#### Property-management sales teams

Enrich host lead lists, identify multi-listing operators, and prioritize accounts with larger reported portfolios.

#### Real estate investors

Research operator concentration, property types, and visible listing quality before deeper market analysis.

#### Regulators and researchers

Create reproducible snapshots of public host-to-listing relationships without signing into Airbnb.

#### Data vendors and developers

Feed normalized host and listing rows into CRMs, warehouses, dashboards, enrichment pipelines, and monitoring jobs.

### Why use this Airbnb host scraper?

Airbnb host pages contain useful structured data, but collecting it manually is slow and inconsistent.

This Actor provides:

- **Batch input** for URLs and host IDs
- **Stable fields** across every dataset row
- **Deduplication** when the same host appears more than once
- **Traceability** through source URLs, statuses, errors, and timestamps
- **Honest coverage** that distinguishes total portfolio size from surfaced listings
- **No-login operation** for public host profiles
- **Optional proxies** for environments where direct access is blocked
- **Apify integrations** for schedules, webhooks, API access, and cloud storage

### What data can you extract?

| Field | Description |
|---|---|
| `rowType` | `listing` for a surfaced property or `host` for an empty/error profile |
| `status` | `ok`, `empty`, or `error` |
| `hostId` | Numeric Airbnb user ID |
| `hostName` | Public host display name |
| `hostLocation` | Public profile location |
| `hostBio` | Public host biography |
| `hostIsSuperhost` | Host-level Superhost flag |
| `hostVerificationTypes` | Verification labels Airbnb exposes publicly |
| `hostManagedListingsTotalCount` | Total managed listings reported by Airbnb |
| `surfacedListingCount` | Listing records returned on the public profile |
| `isPortfolioTruncated` | Whether reported total exceeds surfaced count |
| `listingId` | Airbnb listing ID |
| `listingUrl` | Canonical Airbnb room URL |
| `listingName` | Public listing name or placeholder name |
| `propertyTypeName` | Property type, such as Apartment |
| `roomType` | Localized public room type |
| `bedrooms`, `bathrooms`, `beds` | Capacity fields when exposed |
| `instantBookEnabled` | Instant Book availability |
| `ratingAverage` | Public average rating |
| `reviewCount` | Public review count |
| `pictureUrl`, `thumbnailUrl` | Public image URLs |
| `scrapedAt` | UTC extraction timestamp |

Airbnb does not populate every listing field on every host page. Missing optional values are omitted rather than guessed.

### How to scrape Airbnb host portfolios

1. Open the Actor input page.
2. Add one or more Airbnb URLs like `https://www.airbnb.com/users/show/107434423`.
3. Optionally add numeric host IDs.
4. Keep the maximum at 10 for all publicly surfaced listings.
5. Leave proxy use disabled unless your environment needs it.
6. Click **Start**.
7. Open the dataset to preview or export the rows.

For repeat monitoring, save the input as an Apify task and attach a schedule.

### Input example

```json
{
  "hostProfileUrls": [
    { "url": "https://www.airbnb.com/users/show/107434423" }
  ],
  "hostIds": [],
  "maxListingsPerHost": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

You may combine URLs and IDs. The Actor normalizes both forms and processes each unique host once.

### Output example

```json
{
  "rowType": "listing",
  "status": "ok",
  "sourceUrl": "https://www.airbnb.com/users/show/107434423",
  "hostProfileUrl": "https://www.airbnb.com/users/show/107434423",
  "hostId": "107434423",
  "hostName": "Georgia",
  "hostLocation": "New York, NY",
  "hostManagedListingsTotalCount": 3584,
  "surfacedListingCount": 10,
  "isPortfolioTruncated": true,
  "listingId": "579362581900442399",
  "listingUrl": "https://www.airbnb.com/rooms/579362581900442399",
  "listingName": "Blueground | Capitol Hill, gym & lounge, nr I5",
  "propertyTypeName": "Apartment",
  "roomType": "Rental unit",
  "bedrooms": 1,
  "bathrooms": 1,
  "beds": 1,
  "instantBookEnabled": true,
  "ratingAverage": 5,
  "reviewCount": 1,
  "scrapedAt": "2026-07-14T00:00:00.000Z"
}
```

Actual values change as Airbnb profiles change.

### Empty, private, and unavailable profiles

Batch workflows need one traceable answer per input.

If a profile has no surfaced listings, the Actor emits a host-only row with `status: "empty"`.

If Airbnb returns an error or no public profile payload, it emits a host-only row with `status: "error"` and a readable `error` field.

These rows are charged like other dataset rows because they are persisted results that preserve input-to-output traceability.

### How much does it cost to scrape Airbnb host portfolios?

The Actor uses pay-per-event pricing:

- A small start charge covers fixed run setup.
- Each saved listing or host-only status row is one result event.
- Apify subscription tiers receive automatic volume discounts.

You can always see the estimated maximum charge before starting a run. Final tier prices shown on the Actor page are authoritative.

A profile usually produces at most 10 rows, so a small lookup remains inexpensive and predictable.

### Accuracy and portfolio coverage

`hostManagedListingsTotalCount` and `surfacedListingCount` measure different things.

For example, a professional operator may have a total count of 3,584 while Airbnb surfaces only 10 representative listings on the public profile.

The Actor does not claim that those 10 records are the operator's full inventory.

Use `isPortfolioTruncated` to identify profiles where the visible subset is smaller than the reported total.

### Tips for reliable runs

- Use canonical `/users/show/<hostId>` profile URLs.
- Prefer numeric host IDs when URLs were copied from systems that add tracking parameters.
- Keep batches moderate and schedule recurring runs instead of sending bursts.
- Configure a proxy only after direct access fails in your environment.
- Filter `status = ok` for listing-only exports.
- Keep host-only rows in monitoring workflows to detect removed or empty profiles.
- Store snapshots with `scrapedAt` when comparing portfolio changes over time.

### Export and integrations

#### Google Sheets and Excel

Export the dataset as CSV or XLSX, or connect Apify to Google Sheets for recurring lead enrichment.

#### Webhooks

Trigger a webhook after each run and send new portfolio rows to your application, CRM, or automation platform.

#### Make and Zapier

Use Apify integrations to start runs from a workflow and route finished dataset items to downstream tools.

#### Data warehouses

Fetch dataset items through the API and load them into BigQuery, Snowflake, PostgreSQL, or your preferred warehouse.

#### Monitoring

Save host inputs as a task, schedule daily or weekly runs, and compare listing IDs or total counts with the previous snapshot.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/airbnb-host-portfolio-scraper').call({
  hostIds: ['107434423'],
  maxListingsPerHost: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/airbnb-host-portfolio-scraper').call(run_input={
    'hostIds': ['107434423'],
    'maxListingsPerHost': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~airbnb-host-portfolio-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"hostIds":["107434423"],"maxListingsPerHost":10}'
```

After the run finishes, read items from its default dataset URL.

### Use with Apify MCP and AI agents

The MCP endpoint for this Actor is:

`https://mcp.apify.com/?tools=automation-lab/airbnb-host-portfolio-scraper`

#### Claude Code setup

```bash
claude mcp add --transport http apify-airbnb-hosts "https://mcp.apify.com/?tools=automation-lab/airbnb-host-portfolio-scraper"
```

#### Claude Desktop setup

Add this configuration to Claude Desktop. The same `mcpServers` JSON works as a starting point for **Cursor** and **VS Code** MCP setup; place it in the MCP configuration file used by that client.

```json
{
  "mcpServers": {
    "apify-airbnb-hosts": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/airbnb-host-portfolio-scraper"
    }
  }
}
```

#### Cursor setup

Open Cursor MCP settings, add a new HTTP server, and use the endpoint above or the `mcpServers` JSON.

#### VS Code setup

Open your MCP server configuration, add an HTTP server named `apify-airbnb-hosts`, and use the same endpoint.

Example prompts:

- “Extract the publicly surfaced listings for Airbnb host 107434423.”
- “Compare these Airbnb host IDs and rank them by reported managed listing count.”
- “Return host name, total portfolio count, listing URLs, ratings, and review counts as JSON.”
- “Check this saved list weekly and identify newly surfaced listing IDs.”

### Responsible use and legality

This Actor extracts information that Airbnb displays on public host profile pages without login.

Public availability does not remove your responsibilities. Follow applicable laws, Airbnb's terms, privacy obligations, and contractual restrictions.

Do not use the data for harassment, discrimination, unauthorized profiling, or decisions that require consent or regulated due process.

Collect only what your use case needs, secure exported data, define retention periods, and honor valid deletion requests.

### Limitations

- Airbnb may change its page structure or public profile payload.
- Public profiles currently surface at most 10 managed listings.
- The surfaced subset is not guaranteed to represent every property a host manages.
- Some property fields are absent on host pages even when available on listing detail pages.
- Removed, private, or non-host profiles may return only a status row.
- Ratings, counts, flags, and images reflect Airbnb's public state at extraction time.
- This Actor does not sign in, solve CAPTCHAs, or access private account data.

### Troubleshooting

#### “Invalid Airbnb host profile URL or host ID”

Use a numeric ID or a URL containing `/users/show/<numeric-id>`. Listing URLs under `/rooms/` are not host profile URLs.

#### A run returns `status: error`

Read the `error` field and run log. Retry transient upstream failures. If direct access is blocked in your environment, enable Apify Proxy in the input.

#### Why are only 10 listings returned?

That is the subset Airbnb publicly surfaces on the host profile. Check `hostManagedListingsTotalCount` and `isPortfolioTruncated` for the reported larger portfolio.

#### Why are some property fields missing?

Airbnb does not include every attribute for every surfaced listing. The Actor omits unavailable values instead of inventing them.

### FAQ

#### Does this scraper require an Airbnb account?

No. It uses public host profile data and does not require Airbnb login credentials.

#### Can it find every listing owned or managed by a host?

No. It extracts only the listing records Airbnb publicly surfaces and clearly reports when the total count is larger.

#### Can I input host IDs instead of URLs?

Yes. Add numeric IDs in `hostIds`; URLs and IDs may be used together.

#### Are duplicate hosts charged twice?

No. Inputs normalize to host IDs, and each unique host is fetched once per run.

#### Can I monitor portfolio changes?

Yes. Schedule a saved task and compare `listingId`, `surfacedListingCount`, and `hostManagedListingsTotalCount` across dated datasets.

#### Does it scrape reviews?

It returns listing review counts, not review text. Use the related Airbnb reviews scraper for review records.

### Related Airbnb scrapers

- [Airbnb Listing Scraper](https://apify.com/automation-lab/airbnb-listing) — extract listing and search data.
- [Airbnb Reviews Scraper](https://apify.com/automation-lab/airbnb-reviews) — collect review records for Airbnb listings.

Choose this Actor when your starting entity is a **host profile** and your goal is a host-to-managed-listing portfolio map.

### Support

If a public host profile stops extracting, open an issue from the Actor page and include:

- the public host URL or ID;
- the run URL;
- the expected versus actual result;
- whether a proxy was enabled.

Do not include passwords, session cookies, private account data, or other secrets.

# Actor input Schema

## `hostProfileUrls` (type: `array`):

Public URLs such as https://www.airbnb.com/users/show/107434423.

## `hostIds` (type: `array`):

Numeric Airbnb user IDs. Duplicate hosts are processed once.

## `maxListingsPerHost` (type: `integer`):

Limit listing rows per profile. Airbnb currently surfaces at most 10 on this public page.

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

Optional Apify Proxy or custom proxy settings.

## Actor input object example

```json
{
  "hostProfileUrls": [
    {
      "url": "https://www.airbnb.com/users/show/107434423"
    }
  ],
  "hostIds": [],
  "maxListingsPerHost": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "hostProfileUrls": [
        {
            "url": "https://www.airbnb.com/users/show/107434423"
        }
    ],
    "maxListingsPerHost": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/airbnb-host-portfolio-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 = {
    "hostProfileUrls": [{ "url": "https://www.airbnb.com/users/show/107434423" }],
    "maxListingsPerHost": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/airbnb-host-portfolio-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 '{
  "hostProfileUrls": [
    {
      "url": "https://www.airbnb.com/users/show/107434423"
    }
  ],
  "maxListingsPerHost": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/airbnb-host-portfolio-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Host Portfolio Scraper",
        "description": "🏠 Map public Airbnb host profiles to surfaced managed listings. Export host details, reported portfolio size, property types, ratings, reviews, images, and canonical URLs.",
        "version": "0.1",
        "x-build-id": "ndWY1MNr8HUr8FyUk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~airbnb-host-portfolio-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-airbnb-host-portfolio-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/automation-lab~airbnb-host-portfolio-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-airbnb-host-portfolio-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/automation-lab~airbnb-host-portfolio-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-airbnb-host-portfolio-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": {
                    "hostProfileUrls": {
                        "title": "Airbnb host profile URLs",
                        "type": "array",
                        "description": "Public URLs such as https://www.airbnb.com/users/show/107434423.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "hostIds": {
                        "title": "Airbnb host IDs",
                        "type": "array",
                        "description": "Numeric Airbnb user IDs. Duplicate hosts are processed once.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxListingsPerHost": {
                        "title": "Maximum surfaced listings per host",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Limit listing rows per profile. Airbnb currently surfaces at most 10 on this public page.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy or custom proxy settings."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
