# Airbnb Scraper 🏠: prices, ratings + availability calendar (`tagadanar/airbnb-scraper`) Actor

Scrape Airbnb listings with accurate nightly prices pulled from the real price breakdown, not rough estimates. Get ratings, reviews, coordinates, host type and each listing's day-by-day availability calendar. It tiles the map so you get every listing in the city, not just the ~270 a search caps at.

- **URL**: https://apify.com/tagadanar/airbnb-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Travel, Real estate, Open source
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 listing scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 Scraper 🏠: prices, ratings and availability calendar

**Scrape Airbnb search results into clean JSON, with reliable nightly prices and each listing's raw availability calendar.** Paste an Airbnb search URL (or just a place name) and get every listing in the area: **name, property type, exact nightly price, rating, review count, coordinates, bedrooms/beds/baths, host type, Superhost and Guest-Favorite badges and photos**, plus, on demand, the listing's **day-by-day availability calendar**. **No login, no API key, no cookies to paste.**

Built for **market research, price monitoring, travel planning, competitor tracking and AI agents** (REST API + MCP).

### Why this Airbnb scraper

The popular Airbnb actors have three chronic complaints: unreliable prices, the ~270-results-per-search ceiling, and no availability data. This one fixes all three:

- 💶 The nightly rate is read straight from Airbnb's own price *breakdown* ("5 nights x $96.98") instead of a screen-scraped headline, so what you get is discount-free and per-night, in any currency.
- 🗺️ When a search maxes out at Airbnb's ~270-result cap, the actor automatically splits the map into quadrants and searches each tile (geo-tiling), which is how it ends up covering whole cities rather than just a slice.
- 📅 **Availability calendar included**: turn on the option and get an opt-in raw calendar per listing, with every future day marked `available`, `minNights` and `bookable`. Other scrapers don't return this at all.
- 🔔 Monitor mode lets you schedule the actor and get only NEW listings per run, with an optional Slack digest, and you're charged for new listings only.
- 🤖 You pay per listing actually returned, not per attempt.

### What you can do with it

- Track nightly rates for an area (or a competitor set) over time, in any currency: classic **price monitoring**.
- Pull inventory, prices, ratings and host mix (private vs professional) for any city or neighborhood, which is the basis of solid **market research**.
- Pull raw calendars to see open vs blocked nights per listing, useful for **availability analysis**.
- Pair monitor mode with a schedule so you get a live feed of newly listed properties, essentially **fresh-supply alerts**.
- **Feed AI agents** structured Airbnb data over REST or MCP.

💡 Want **occupancy %, RevPAR, projected revenue and market-level reports** computed for you? That's what our companion actor, **[Airbnb Occupancy, ADR & Market Report](https://apify.com/tagadanar/airbnb-str-yield)**, is for: it turns this raw data into AirDNA-style yield analytics.

### Quick start

```json
{
    "searchUrls": ["https://www.airbnb.com/s/Paris/homes"],
    "maxListings": 500
}
````

Or skip the URL and use place names + dates (dated searches return exact quoted prices):

```json
{
    "locationQueries": ["Lisbon", "Porto"],
    "checkIn": "2026-08-01",
    "checkOut": "2026-08-08",
    "adults": 2,
    "currency": "USD",
    "includeCalendar": true,
    "calendarMonths": 6
}
```

### Output (per listing)

```json
{
    "source": "Airbnb",
    "id": "51692151",
    "url": "https://www.airbnb.com/rooms/51692151",
    "name": "Charming flat near Montmartre",
    "propertyType": "Apartment",
    "city": "Paris",
    "latitude": 48.884,
    "longitude": 2.337,
    "bedrooms": 1,
    "beds": 2,
    "bathrooms": 1,
    "hostType": "Private host",
    "isPrivateHost": true,
    "rating": 4.95,
    "reviewCount": 122,
    "isGuestFavorite": true,
    "superhost": false,
    "pricePerNight": 96.98,
    "priceSource": "breakdown",
    "displayTotalPrice": 484.9,
    "currency": "EUR",
    "photos": ["https://a0.muscache.com/im/pictures/..."],
    "calendar": [
        { "date": "2026-07-07", "available": true, "minNights": 2, "bookable": true },
        { "date": "2026-07-08", "available": false, "minNights": 2, "bookable": false }
    ],
    "calendarDays": 184,
    "scrapedAt": "2026-07-06T10:00:00.000Z"
}
```

### Pricing

Pay per event, no subscription:

| Event | Price | When |
|---|---|---|
| Listing scraped | **$1.00 / 1,000** | Per unique listing returned |
| Calendar fetched | **$0.50 / 1,000** | Per listing calendar attached (only with `includeCalendar`) |
| Actor start | $0.00005 (≈ zero) | Once per run |

Apify platform usage (compute + residential proxy) is billed separately at platform rates.

### FAQ

**How do I scrape more than 270 listings for a city?** Nothing to configure. Airbnb caps any single search at ~270 results; the actor detects the cap and recursively splits the map area into quadrants, de-duplicating listings across tiles.

**Are the prices accurate?** The nightly rate comes from Airbnb's own price breakdown when available (`priceSource: "breakdown"`), which is the true per-night figure without the discount/total ambiguity. Add `checkIn`/`checkOut` for exact quoted prices for your dates; undated searches show Airbnb's default-window prices.

**What's in the calendar, exactly?** Airbnb's public per-day availability: `available`, `minNights`, `bookable` for up to 12 months ahead. It does not distinguish bookings from host blocks, so for inferred occupancy, RevPAR and revenue projections, use the [STR Yield actor](https://apify.com/tagadanar/airbnb-str-yield).

**Which Airbnb domains work?** Any of them: airbnb.com, airbnb.fr, airbnb.co.uk and so on. Prices parse in any currency; set `currency` to force one.

**Do I need to log in or provide cookies?** No. The actor reads the same public data the search page renders server-side, plus Airbnb's public calendar API.

**How do I export the data?** Through Apify's dataset export (CSV, Excel or JSON), or the API `.../dataset/items?format=csv`.

**Is it reliable?** No hardcoded API hashes: the actor mints Airbnb's rotating calendar-query hash at runtime from a real page, so Airbnb front-end deploys don't break it. Residential proxy is used by default.

**Can I use it with AI agents?** Yes, via REST API and **MCP**.

***

### Something missing?

If you need an extra field, another source, or a different output, open an issue on this Actor and describe it. I read every request and small additions usually ship within days. More data and lead generation Actors are on [my profile](https://apify.com/tagadanar).

*Keywords: airbnb scraper, scrape airbnb, airbnb data, airbnb prices, airbnb listings scraper, airbnb availability calendar, airbnb calendar scraper, airbnb market research, airbnb price monitoring, airbnb api alternative, vacation rental data, short term rental data, MCP.*

# Actor input Schema

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

Paste one or more Airbnb search-results URLs — build the search on airbnb.com (any airbnb.\* domain works) with your filters/dates and copy the page URL, e.g. <code>https://www.airbnb.com/s/Paris/homes</code>.

## `locationQueries` (type: `array`):

Alternative to URLs: plain place names (e.g. <code>Lisbon</code>, <code>Nice, France</code>). Combine with the check-in/check-out fields below.

## `checkIn` (type: `string`):

Optional, <code>YYYY-MM-DD</code>. Applied to <b>locationQueries</b> searches (URLs keep their own dates). Dated searches return exact quoted prices.

## `checkOut` (type: `string`):

Optional, <code>YYYY-MM-DD</code>.

## `adults` (type: `integer`):

Optional guest count for locationQueries searches.

## `children` (type: `integer`):

Optional. Number of children (locationQueries searches).

## `infants` (type: `integer`):

Optional. Number of infants under 2 (locationQueries searches).

## `pets` (type: `integer`):

Optional. Number of pets — only pet-friendly listings are returned (locationQueries searches).

## `currency` (type: `string`):

Optional ISO code (e.g. <code>USD</code>, <code>EUR</code>). Forces all prices into this currency.

## `includeCalendar` (type: `boolean`):

Attach each listing's raw availability calendar (per-day <code>available</code> / <code>minNights</code> / <code>bookable</code>) — the data other Airbnb scrapers don't return. Adds one light API call per listing.

## `calendarMonths` (type: `integer`):

How many months of forward availability to read per listing.

## `onlyPrivateHost` (type: `boolean`):

Keep only listings hosted by a private individual, dropping professional property managers.

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

Keep only listings at or above this nightly price. For place-name searches it is applied inside the Airbnb search itself (faster).

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

Keep only listings at or below this nightly price. For place-name searches it is applied inside the Airbnb search itself (faster).

## `minBedrooms` (type: `integer`):

Only listings with at least this many bedrooms (locationQueries searches).

## `minBeds` (type: `integer`):

Only listings with at least this many beds (locationQueries searches).

## `minBathrooms` (type: `integer`):

Only listings with at least this many bathrooms (locationQueries searches).

## `minRating` (type: `integer`):

Keep only listings with at least this average rating (whole number, out of 5).

## `minReviews` (type: `integer`):

Keep only listings with at least this many reviews.

## `propertyTypes` (type: `array`):

Keep only listings whose type contains one of these words (e.g. <code>Apartment</code>, <code>House</code>). Empty = all.

## `monitorMode` (type: `boolean`):

Remember what previous runs reported (per <code>monitorName</code>) and return only <b>new</b> listings. Schedule it for a live feed of fresh supply — you're charged for new listings only.

## `monitorName` (type: `string`):

Name for this watch's memory of already-seen listings. Use a distinct name per saved search.

## `webhookUrl` (type: `string`):

Optional. A Slack incoming-webhook URL (or any endpoint) that receives a digest of the new listings — pairs with monitor mode + a schedule.

## `maxListings` (type: `integer`):

Stop after this many unique listings across all searches.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.airbnb.com/s/Paris/homes"
  ],
  "locationQueries": [],
  "includeCalendar": false,
  "calendarMonths": 3,
  "onlyPrivateHost": false,
  "propertyTypes": [],
  "monitorMode": false,
  "monitorName": "default",
  "maxListings": 24
}
```

# Actor output Schema

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

One item per listing.

# 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 = {
    "searchUrls": [
        "https://www.airbnb.com/s/Paris/homes"
    ],
    "calendarMonths": 3,
    "maxListings": 24
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/airbnb-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 = {
    "searchUrls": ["https://www.airbnb.com/s/Paris/homes"],
    "calendarMonths": 3,
    "maxListings": 24,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/airbnb-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 '{
  "searchUrls": [
    "https://www.airbnb.com/s/Paris/homes"
  ],
  "calendarMonths": 3,
  "maxListings": 24
}' |
apify call tagadanar/airbnb-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Scraper 🏠: prices, ratings + availability calendar",
        "description": "Scrape Airbnb listings with accurate nightly prices pulled from the real price breakdown, not rough estimates. Get ratings, reviews, coordinates, host type and each listing's day-by-day availability calendar. It tiles the map so you get every listing in the city, not just the ~270 a search caps at.",
        "version": "0.1",
        "x-build-id": "qdbVXiwa5OSDQDzEL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~airbnb-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-airbnb-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/tagadanar~airbnb-scraper/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-airbnb-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/tagadanar~airbnb-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-airbnb-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": {
                    "searchUrls": {
                        "title": "Airbnb search URLs",
                        "type": "array",
                        "description": "Paste one or more Airbnb search-results URLs — build the search on airbnb.com (any airbnb.* domain works) with your filters/dates and copy the page URL, e.g. <code>https://www.airbnb.com/s/Paris/homes</code>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationQueries": {
                        "title": "Or just place names",
                        "type": "array",
                        "description": "Alternative to URLs: plain place names (e.g. <code>Lisbon</code>, <code>Nice, France</code>). Combine with the check-in/check-out fields below.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkIn": {
                        "title": "Check-in date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional, <code>YYYY-MM-DD</code>. Applied to <b>locationQueries</b> searches (URLs keep their own dates). Dated searches return exact quoted prices."
                    },
                    "checkOut": {
                        "title": "Check-out date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional, <code>YYYY-MM-DD</code>."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Optional guest count for locationQueries searches."
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "maximum": 15,
                        "type": "integer",
                        "description": "Optional. Number of children (locationQueries searches)."
                    },
                    "infants": {
                        "title": "Infants",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Optional. Number of infants under 2 (locationQueries searches)."
                    },
                    "pets": {
                        "title": "Pets",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Optional. Number of pets — only pet-friendly listings are returned (locationQueries searches)."
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Optional ISO code (e.g. <code>USD</code>, <code>EUR</code>). Forces all prices into this currency."
                    },
                    "includeCalendar": {
                        "title": "Include availability calendar",
                        "type": "boolean",
                        "description": "Attach each listing's raw availability calendar (per-day <code>available</code> / <code>minNights</code> / <code>bookable</code>) — the data other Airbnb scrapers don't return. Adds one light API call per listing.",
                        "default": false
                    },
                    "calendarMonths": {
                        "title": "Calendar months ahead",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "How many months of forward availability to read per listing.",
                        "default": 6
                    },
                    "onlyPrivateHost": {
                        "title": "Private hosts only",
                        "type": "boolean",
                        "description": "Keep only listings hosted by a private individual, dropping professional property managers.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Minimum nightly price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings at or above this nightly price. For place-name searches it is applied inside the Airbnb search itself (faster)."
                    },
                    "maxPrice": {
                        "title": "Maximum nightly price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings at or below this nightly price. For place-name searches it is applied inside the Airbnb search itself (faster)."
                    },
                    "minBedrooms": {
                        "title": "Minimum bedrooms",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Only listings with at least this many bedrooms (locationQueries searches)."
                    },
                    "minBeds": {
                        "title": "Minimum beds",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Only listings with at least this many beds (locationQueries searches)."
                    },
                    "minBathrooms": {
                        "title": "Minimum bathrooms",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Only listings with at least this many bathrooms (locationQueries searches)."
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Keep only listings with at least this average rating (whole number, out of 5)."
                    },
                    "minReviews": {
                        "title": "Minimum reviews",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only listings with at least this many reviews."
                    },
                    "propertyTypes": {
                        "title": "Property types",
                        "type": "array",
                        "description": "Keep only listings whose type contains one of these words (e.g. <code>Apartment</code>, <code>House</code>). Empty = all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "monitorMode": {
                        "title": "Monitor mode (new listings only)",
                        "type": "boolean",
                        "description": "Remember what previous runs reported (per <code>monitorName</code>) and return only <b>new</b> listings. Schedule it for a live feed of fresh supply — you're charged for new listings only.",
                        "default": false
                    },
                    "monitorName": {
                        "title": "Monitor name",
                        "type": "string",
                        "description": "Name for this watch's memory of already-seen listings. Use a distinct name per saved search.",
                        "default": "default"
                    },
                    "webhookUrl": {
                        "title": "Slack / webhook URL",
                        "type": "string",
                        "description": "Optional. A Slack incoming-webhook URL (or any endpoint) that receives a digest of the new listings — pairs with monitor mode + a schedule."
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop after this many unique listings across all searches.",
                        "default": 300
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```