# Airbnb Full-Year Price Scraper (`cirkit/airbnb-full-year-price-scraper`) Actor

Returns one row per calendar day for the next 12 months of any Airbnb listing, with the actual nightly price filled in. Unlike availability-only scrapers, this resolves real prices by calling Airbnb's booking API per day.

- **URL**: https://apify.com/cirkit/airbnb-full-year-price-scraper.md
- **Developed by:** [Crikit](https://apify.com/cirkit) (community)
- **Categories:** Real estate
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Full-Year Price Scraper

Get the **real host-set nightly price** for every available day of any Airbnb listing, for up to 12 months ahead. One row per calendar date, with availability flags, minimum-stay rules, instant-book status, and the actual booking-quote price (including any discount the host has applied) populated for every bookable day.

This is the actor you reach for when you need to track Airbnb pricing over a full year for revenue management, market research, comp analysis, or short-term-rental dashboards. It calls Airbnb's calendar API for availability and Airbnb's booking-quote API per date window to resolve the exact same price your guests see when they click "Reserve."

### Why this exists

Other Airbnb calendar scrapers on Apify all use `PdpAvailabilityCalendar`, which is the obvious endpoint and which returns `price: null` for every day. They ship that null and call it done.

This actor uses Airbnb's `StaysPdpBookItQuery`, the API that powers the booking sidebar, with the right combination of fragment-include flags to unlock the full pricing payload. You get the same numbers a guest sees on the listing page: nightly rate, total for the stay, original price, discounted price, discount amount, instant-book eligibility, and the host's booking tips.

### What you give it

| Field | Type | Required | Notes |
|---|---|---|---|
| `listingUrls` | array of URLs | yes (or `listingIds`) | Airbnb listing URLs like `https://www.airbnb.com/rooms/18850420`. |
| `listingIds` | array of strings | yes (or `listingUrls`) | Numeric listing IDs as an alternative to URLs. |
| `currency` | string | no, default USD | ISO-4217 currency code. Airbnb does the conversion server-side. |
| `adults` | integer | no, default 2 | Adult guest count used in booking quotes. Some listings price per guest. |
| `monthsAhead` | integer | no, default 12 | How many months of calendar to scrape (max 24). |
| `fetchPrices` | boolean | no, default true | Set false to skip booking-quote calls and return only availability. |
| `onlyAvailableDays` | boolean | no, default false | Set true to skip rows for dates the host has blocked. |
| `maxItems` | integer | no | Hard cap on rows pushed across all listings. |
| `proxyConfiguration` | object | no | Defaults to Apify Residential Proxy. Required for sustained throughput. |

### What you get back

One row per calendar date per listing. Every available day carries the actual booking-quote price.

| Field | Type | Notes |
|---|---|---|
| `listingId` | string | Numeric Airbnb listing ID. |
| `listingUrl` | string | Canonical Airbnb URL. |
| `listingTitle` | string | The host-set listing name (e.g. "Romantic loft downtown"). |
| `listingLatitude` / `listingLongitude` | number | Listing coordinates. |
| `calendarDate` | string | `YYYY-MM-DD`. |
| `available` | boolean | Host's calendar marks the date open. |
| `bookable` | boolean | Per calendar API (less reliable; use `bookItAvailable`). |
| `availableForCheckin` / `availableForCheckout` | boolean | Per calendar API. |
| `minNights` | integer | Minimum stay if checking in on this date. |
| `maxNights` | integer | Maximum stay if checking in on this date. |
| `bookItAvailable` | boolean | Authoritative bookability for the priced window. |
| `canInstantBook` | boolean | Instant-book eligibility flag from Airbnb. |
| `unavailabilityMessage` | string | Reason Airbnb gives when the window is not bookable. |
| `currency` | string | ISO 4217 code (matches the input `currency`). |
| `nightlyPrice` | number | **Real nightly rate** from the booking quote. |
| `nightlyPriceFormatted` | string | e.g. `$1,236.40 USD`. |
| `originalPrice` | number | Window total before any discount (when applicable). |
| `originalPriceFormatted` | string | e.g. `$6,182 USD`. |
| `discountedPrice` | number | Window total after the host or platform discount. |
| `discountedPriceFormatted` | string | e.g. `$5,046 USD`. |
| `discountAmount` | number | Absolute amount of the discount on the window. |
| `priceAfterDiscount` | number | Price after discount, before taxes. |
| `priceAfterDiscountFormatted` | string | e.g. `$5,045.60 USD`. |
| `totalForWindow` | number | Top-line price for the priced window. |
| `totalForWindowFormatted` | string | Formatted version of `totalForWindow`. |
| `priceWindowNights` | integer | Number of nights the window covers. |
| `priceBreakdown` | array | Itemized breakdown: per-night subtotal, discount lines, fees. |
| `priceAccessibilityLabel` | string | Long-form description, e.g. `"$5,046 for 5 nights, originally $6,182"`. |
| `priceQualifier` | string | e.g. `for 5 nights`, `total`. |
| `integratedTip` | string | Free-cancellation tip, e.g. `Free cancellation before June 14`. |
| `promotionAnnouncement` | string | e.g. `This host is offering a discount`, `Rare find!`. |
| `adults` | integer | Guest count used to fetch this quote. |
| `scrapedAt` | string | ISO-8601 timestamp. |

### Pricing

Flat $0.008 per daily-price row. A full year of one listing is 365 rows = $2.92.

The leading competitor charges $0.003 per row plus $0.01 extra per priced date = $0.013 per priced day. They also return null prices for every day. We are 38% cheaper AND actually deliver the price.

**Worked examples:**

- 1 listing, 12 months, with prices: 365 rows × $0.008 = $2.92
- 10 listings, 12 months, with prices: 3,650 rows × $0.008 = $29.20
- 100 listings, 12 months, with prices: 36,500 rows × $0.008 = $292.00

### How it works under the hood

1. **Availability grid.** One call to `PdpAvailabilityCalendar` returns 12 months of day-level data: `available`, `minNights`, `maxNights`, `availableForCheckin/out` flags.

2. **Per-window booking quote.** The actor chunks the year into non-overlapping windows aligned to each listing's `minNights`. For every window with at least one available day, it issues a `StaysPdpBookItQuery` with all of these include-flags set to true:
   - `includePdpMigrationBookItCalendarSheetFragment`
   - `includePdpMigrationBookItFloatingFooterFragment`
   - `includePdpMigrationBookItNavFragment`
   - `includePdpMigrationBookItSidebarFragment`
   - `includeOverviewMerchandisingTipsFragment`

   With them all true, the response returns the full booking sidebar payload: `structuredDisplayPrice` with `discountedPrice`, `originalPrice`, per-night breakdown, plus availability, instant-book, and merchandising tips. (With them all false, you only get the empty node skeleton, which is why most competing scrapers ship null prices.)

3. **Row emission.** Per calendar day, the actor emits one row carrying the calendar flags plus the booking-quote data for whichever window covered that date. If a window came back `isAvailable: false` from BookIt, the calendar's "available" flag is preserved but the booking fields are null (consistent with what a guest sees).

4. **Rate-limit handling.** Airbnb's API sits behind Akamai with per-IP rate limits. The actor uses Apify Residential Proxy with per-request session rotation: every API call gets a fresh upstream IP, so 429s don't cascade.

### Limits to be aware of

- **12 months is Airbnb's hard cap.** The calendar endpoint silently clamps `count > 12` to 12. The actor stitches multiple calls automatically when `monthsAhead > 12`.
- **Min-stay listings (>14 nights)** have larger windows, so per-night cost is lower; you still get the same per-day row.
- **Calendar-available vs BookIt-available**: the calendar API sometimes says "available" for dates the host actually won't accept as a booking (day-of-week-only checkin, holiday blackouts). `bookItAvailable` is authoritative.
- **Pre-booked dates** legitimately have no price. The row appears with `available: false, nightlyPrice: null`.
- **Currency conversion** is server-side. Pass `currency=EUR` and Airbnb returns EUR prices.

### FAQ

**Why is this cheaper than the next-best competitor?**
They charge $0.003 per row plus $0.01 extra when prices exist. A priced year of one listing is 365 × $0.013 = $4.75. We do it at $0.008 flat per row = $2.92. And we actually return the price, where they return null.

**Does the actor return the same price I'd see if I clicked "Reserve" on the listing page?**
Yes. The booking-quote API the actor hits is the same one your browser hits when it renders the booking sidebar. Discounts, promotional rates, and instant-book status are all what a guest would see.

**Can I scrape multiple listings in one run?**
Yes. Paste any number of URLs into `listingUrls`. The actor processes three listings at a time, each fanning out internally to eight concurrent booking-quote calls.

**Does this require my login or session cookie?**
No. Airbnb's public API key is hardcoded into every airbnb.com page; the actor uses that. No authentication, no PII.

### Changelog

- `0.2`: switched price source from search-bbox to `StaysPdpBookItQuery` with all fragment-include flags enabled. Adds discount, original price, instant-book, and merchandising-tip data. Real nightly rates match what guests see at booking.
- `0.1`: initial release. Calendar + per-day booking-quote pipeline. Residential proxy rotation. Multi-listing concurrency.

# Actor input Schema

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

Airbnb listing URLs like https://www.airbnb.com/rooms/37879131. Each URL is processed independently.
## `listingIds` (type: `array`):

Alternative to URLs. Provide raw numeric Airbnb listing IDs.
## `currency` (type: `string`):

ISO 4217 currency code for returned prices. Airbnb performs the conversion server-side.
## `adults` (type: `integer`):

Number of adult guests used when fetching price quotes. Different guest counts can change the per-night rate on some listings.
## `monthsAhead` (type: `integer`):

How many months of calendar to scrape. Airbnb's API returns up to 12 at a time; setting >12 makes multiple calls.
## `fetchPrices` (type: `boolean`):

If true (default), call the booking API for each available day to resolve the real nightly price. If false, only return availability flags (much faster, but the price field will be null).
## `onlyAvailableDays` (type: `boolean`):

If true, skip rows for unavailable dates. By default the actor returns one row per calendar date, available or not.
## `maxItems` (type: `integer`):

Hard cap on the total number of rows pushed across all listings. Leave empty for no limit (one full year of data per listing).
## `proxyConfiguration` (type: `object`):

Airbnb rate-limits per IP. The actor uses Apify Residential Proxy by default to rotate IPs and avoid 429 cooldowns.

## Actor input object example

```json
{
  "listingUrls": [
    {
      "url": "https://www.airbnb.com/rooms/18850420"
    }
  ],
  "listingIds": [],
  "currency": "USD",
  "adults": 2,
  "monthsAhead": 12,
  "fetchPrices": true,
  "onlyAvailableDays": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# Actor output Schema

## `items` (type: `string`):

All scraped daily-price rows.

## `itemsCsv` (type: `string`):

Daily-price rows in CSV format, ready for spreadsheet import.

## `itemsJson` (type: `string`):

Daily-price rows in JSON format.

## `itemsExcel` (type: `string`):

Daily-price rows in XLSX format.

## `consoleRun` (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 = {
    "listingUrls": [
        {
            "url": "https://www.airbnb.com/rooms/18850420"
        }
    ],
    "currency": "USD",
    "adults": 2,
    "monthsAhead": 12,
    "fetchPrices": true,
    "onlyAvailableDays": false,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cirkit/airbnb-full-year-price-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 = {
    "listingUrls": [{ "url": "https://www.airbnb.com/rooms/18850420" }],
    "currency": "USD",
    "adults": 2,
    "monthsAhead": 12,
    "fetchPrices": True,
    "onlyAvailableDays": False,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("cirkit/airbnb-full-year-price-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 '{
  "listingUrls": [
    {
      "url": "https://www.airbnb.com/rooms/18850420"
    }
  ],
  "currency": "USD",
  "adults": 2,
  "monthsAhead": 12,
  "fetchPrices": true,
  "onlyAvailableDays": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call cirkit/airbnb-full-year-price-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Airbnb Full-Year Price Scraper",
        "description": "Returns one row per calendar day for the next 12 months of any Airbnb listing, with the actual nightly price filled in. Unlike availability-only scrapers, this resolves real prices by calling Airbnb's booking API per day.",
        "version": "0.1",
        "x-build-id": "4cZhpfARUlQdreFxq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/cirkit~airbnb-full-year-price-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-cirkit-airbnb-full-year-price-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/cirkit~airbnb-full-year-price-scraper/runs": {
            "post": {
                "operationId": "runs-sync-cirkit-airbnb-full-year-price-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/cirkit~airbnb-full-year-price-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-cirkit-airbnb-full-year-price-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",
                "required": [
                    "listingUrls"
                ],
                "properties": {
                    "listingUrls": {
                        "title": "Listing URLs",
                        "type": "array",
                        "description": "Airbnb listing URLs like https://www.airbnb.com/rooms/37879131. Each URL is processed independently.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "listingIds": {
                        "title": "Listing IDs (numeric)",
                        "type": "array",
                        "description": "Alternative to URLs. Provide raw numeric Airbnb listing IDs.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD",
                            "JPY",
                            "CHF",
                            "CNY",
                            "INR",
                            "MXN",
                            "BRL",
                            "ARS",
                            "ZAR",
                            "SEK",
                            "NOK",
                            "DKK",
                            "PLN",
                            "CZK",
                            "HUF",
                            "RUB",
                            "TRY",
                            "AED",
                            "SAR",
                            "ILS",
                            "SGD",
                            "HKD",
                            "TWD",
                            "KRW",
                            "THB",
                            "MYR",
                            "IDR",
                            "PHP",
                            "VND",
                            "NZD",
                            "CLP",
                            "COP",
                            "PEN"
                        ],
                        "type": "string",
                        "description": "ISO 4217 currency code for returned prices. Airbnb performs the conversion server-side.",
                        "default": "USD"
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Number of adult guests used when fetching price quotes. Different guest counts can change the per-night rate on some listings.",
                        "default": 2
                    },
                    "monthsAhead": {
                        "title": "Months ahead",
                        "minimum": 1,
                        "maximum": 24,
                        "type": "integer",
                        "description": "How many months of calendar to scrape. Airbnb's API returns up to 12 at a time; setting >12 makes multiple calls.",
                        "default": 12
                    },
                    "fetchPrices": {
                        "title": "Fetch nightly prices",
                        "type": "boolean",
                        "description": "If true (default), call the booking API for each available day to resolve the real nightly price. If false, only return availability flags (much faster, but the price field will be null).",
                        "default": true
                    },
                    "onlyAvailableDays": {
                        "title": "Only return available days",
                        "type": "boolean",
                        "description": "If true, skip rows for unavailable dates. By default the actor returns one row per calendar date, available or not.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on the total number of rows pushed across all listings. Leave empty for no limit (one full year of data per listing)."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Airbnb rate-limits per IP. The actor uses Apify Residential Proxy by default to rotate IPs and avoid 429 cooldowns.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```