# Hostelworld Rate & Availability Monitor (`zhorex/hostelworld-rate-monitor`) Actor

Forward-dated hostel rate calendar: price, dorm/private split, promo stack, organic ranking position and commission split per property per date. Delta mode returns only what moved. No login, no API key, no browser.

- **URL**: https://apify.com/zhorex/hostelworld-rate-monitor.md
- **Developed by:** [Sami](https://apify.com/zhorex) (community)
- **Categories:** Travel, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 rate-calendar rows

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Hostelworld Rate & Availability Monitor — Hostel Comp-Set Pricing by Date (2026)

Build a **forward-dated rate calendar** for any hostel comp set: one row per property per arrival date per guest configuration, carrying the lowest rate, the dorm/private split, the **pre-discount rate and the full promo stack**, the property's **organic ranking position**, and Hostelworld's own **per-date commission split**. Turn on delta mode and a daily schedule returns only what *moved* — the price, the promo, the rank, or a property that vanished from a date it was previously priced on.

No login. No API key. No browser. Clean JSON / CSV / Excel, billed per row you actually receive.

### How to build your comp set in 3 steps

1. **Find your city id.** Run mode **City index** with a `countryId` (England = 237) and you get every city with its Hostelworld id. Or skip it: London = `3`, Munich = `20`.
2. **Set the window.** `cityIds` + `startDaysAhead` + `horizonDays`. One city over 30 forward dates = 30 requests and a full month of priced comp set.
3. **Click Run.** Then add an [Apify Schedule](https://docs.apify.com/platform/schedules) with `deltaMode: true` and you have a movement feed instead of a one-off snapshot.

### Why this is not another listings scraper

Every other Hostelworld actor on the Store dumps a list of properties. This one is built around the three things a revenue manager or a travel analyst actually acts on — and they are all in the response, unused by everyone else:

| Field group | What you get | Why it matters |
|---|---|---|
| **Ranking** | `position`, `isPromoted`, `isFeatured`, `isElevate`, `hostelworldRecommends`, `veryPopular` | Where you sit in the organic list for that date. Price without visibility explains nothing |
| **Promo stack** | `promoTypes`, `promoNames`, `promoMaxDiscountPct`, `promoStackable`, `originalLowestAveragePricePerNight`, `discountPct` | Pre-discount vs sold rate, and *which* promos are stacking (LOS, MOBILE, CUSTOM). This is how you read a competitor's discounting strategy |
| **Commission** | `marginTotalPct`, `marginElevatePct`, `marginFlCommissionPct`, `marginContractualPct` | The per-property per-date commission split the platform applies. It is **not** in Hostelworld's official partner API |

Plus the ordinary essentials: lowest / dorm / private rates, currency, rating and review count, seven rating sub-scores, free-cancellation window and deadline, district, coordinates, distance from centre.

### What a row looks like

```json
{
    "propertyId": 14348,
    "propertyName": "Palmers Lodge - Swiss Cottage",
    "propertyType": "HOSTEL",
    "arrivalDate": "2026-08-15",
    "nights": 2,
    "guests": 2,
    "currency": "EUR",
    "cityId": 3,
    "cityName": "London",
    "countryName": "England",
    "districtName": "Camden",
    "lowestPricePerNight": 19.54,
    "lowestDormPricePerNight": 19.54,
    "lowestPrivatePricePerNight": 91.13,
    "lowestAveragePricePerNight": 29.68,
    "originalLowestAveragePricePerNight": 43.21,
    "discountPct": 31.31,
    "position": 2,
    "isPromoted": true,
    "promoCount": 3,
    "promoTypes": ["CUSTOM", "MOBILE", "LOS"],
    "promoMaxDiscountPct": 27,
    "promoStackable": true,
    "marginTotalPct": 21.0,
    "marginElevatePct": 4.0,
    "marginFlCommissionPct": 2.0,
    "marginContractualPct": 15.0,
    "overallRating": 88,
    "numberOfRatings": 17341,
    "ratingSecurity": 94,
    "ratingLocation": 88,
    "ratingStaff": 90,
    "ratingClean": 86,
    "ratingValue": 88,
    "freeCancellationAvailable": true,
    "freeCancellationUntil": "2026-08-13T23:59:59+01:00",
    "distanceFromCentre": 6.5,
    "scrapedAt": "2026-07-25T18:40:00Z"
}
````

### Delta mode — a cron that bills for movement, not for re-reading

With `deltaMode: true`, the first run records a baseline and every later run returns **only cells that changed**, each tagged with `changeType`:

| `changeType` | Meaning | Extra fields |
|---|---|---|
| `new` | Property appeared in this city-date list | — |
| `price_up` / `price_down` | The cheapest bed moved | `previousPrice`, `priceChange`, `priceChangePct` |
| `promo_change` | The promo stack or its depth changed | `previousPromoMaxDiscountPct` |
| `rank_change` | Organic position moved by 2 slots or more | `previousPosition`, `positionChange` |
| `disappeared` | Priced on a previous run, absent now | `previousPrice`, `previousPosition` |

**About `disappeared`:** this data carries no availability flag — a sold-out property simply stops appearing for that date. So absence *is* the signal, and it is only emitted for city-date-guest scopes that this run actually swept, which means narrowing your input can never fabricate a wave of false sold-outs.

Unchanged cells are **not returned and not charged**. A quiet day on a cronned comp set costs almost nothing beyond the run itself.

```json
{
    "mode": "rate_calendar",
    "cityIds": ["3"],
    "startDaysAhead": 1,
    "horizonDays": 30,
    "guests": 2,
    "nights": 2,
    "currency": "EUR",
    "deltaMode": true,
    "deltaStateKey": "london-compset"
}
```

### Who this is for

| Buyer | Use |
|---|---|
| **Hostel groups and revenue managers** | Watch your comp set's forward calendar, catch a rival's promo the day it lands, see whether your rank moved when you cut price |
| **Travel and OTA analysts** | Dorm-bed pricing by city and season — a segment the hotel-rate feeds do not cover |
| **Consumer and travel-sector funds** | Budget-accommodation pricing as a demand proxy across cities and months |
| **Channel managers and rate-parity teams** | Pre-discount vs sold rate, promo stacking and commission tiers in one normalised schema |
| **City tourism boards and researchers** | Budget-bed capacity and price levels by district |

### Sizing your run (and your bill)

Rows = **cities × dates**, one request each, and a whole city arrives in a single request (London returns 83 properties at once, Munich 17).

| Setup | Requests | Rows | At $0.007/row |
|---|---|---|---|
| 1 city, 30 dates, one-off | 30 | ~2,500 | ~$17.50 |
| 1 city, 30 dates, daily cron **with delta** | 30/day | only what moved | typically 5-15% of the snapshot |
| 5 cities, 60 dates, weekly | 300 | ~15,000 | ~$105 |

`dateStepDays: 7` is the cheap way to watch a long season: same weekday each week instead of every date. A single run is capped at 2,000 city-date combinations so a typo cannot launch a runaway sweep.

### Pricing

| Event | Price | What it is |
|---|---|---|
| `rate-row` | **$0.007** | One property priced for one arrival date and guest configuration, full field set |
| `rate-change` | **$0.009** | One cell that moved in delta mode, with its previous values |
| `city-record` | **$0.001** | One city with its id, from the lookup mode |

Rows that fail to fetch are pushed as error records with the reason — **and are never charged**.

### Limitations, stated plainly

- **No availability flag exists.** Sold-out is inferred from a property leaving the list for a date. That is honest and useful, but it is an inference.
- **Rates cannot be backfilled.** Nobody can retro-fetch a price for a date that has passed, this Actor included. A rate history exists only from the day your cron starts — which is exactly why starting the schedule early is worth more than any single run.
- **Prices are the lowest available for the configuration you asked for**, not a full room-type inventory. Sweep the stay lengths and guest counts your own guests book, since length-of-stay promotions only appear at the night counts they apply to.
- **Only Hostelworld's inventory.** The same hostel on another channel may show a different rate; this is the Hostelworld view, which is what Hostelworld ranking and commission apply to.

### FAQ

**Do I need a proxy?** No. This data is served keyless to ordinary datacenter IPs — verified with 25 rapid consecutive requests and no throttling. The proxy input exists if you want it, but turning it on adds cost without improving results.

**Do I need a Hostelworld account or partner key?** No. The official partner API does exist, but it is gated behind manual affiliate approval and an HMAC-signed key — and it does not expose the commission split this Actor returns.

**Why is my first delta run large?** It is the baseline. From the second run on you only get movement.

**Can I track private rooms only?** Every row carries `lowestPrivatePricePerNight` alongside the dorm price, so filter on that field.

### Other scrapers by Zhorex

- [Booking.com Reviews Scraper](https://apify.com/zhorex/booking-reviews-scraper) — guest reviews with sentiment, delta mode for new-review monitoring
- [Trustpilot Brand Watch](https://apify.com/zhorex/trustpilot-brand-watch) — delta-mode review monitor across 8 locales

### Legal

This Actor collects publicly available commercial listing data: property names, prices, promotions, rankings and ratings. It does not collect personal data about guests or reviewers. Respect Hostelworld's terms and applicable law in your jurisdiction, and use the data for analysis rather than redistribution.

# Actor input Schema

## `mode` (type: `string`):

'Rate calendar' builds the priced comp set: one row per property per arrival date per guest configuration, with price, promo stack, organic ranking position and Hostelworld's own commission split. 'City index' is the lookup utility — give it a country id and it returns that country's cities with their ids, so you can find the cityIds you need.

## `cityIds` (type: `array`):

Hostelworld city ids to sweep. London = 3, Munich = 20. Don't know yours? Run mode 'City index' with a countryId first (England = 237). One request is issued per city per arrival date, and a whole city fits in a single request — London returns 83 properties at once.

## `countryIds` (type: `array`):

Only used by 'City index' mode. England = 237. Returns each country's cities with ids and coordinates.

## `startDaysAhead` (type: `integer`):

How far ahead the calendar starts. 1 = tomorrow. Rates for tonight behave differently from forward rates, so most comp-set work starts at 1 or 7.

## `horizonDays` (type: `integer`):

How many arrival dates to price, counting from the first. 30 gives a month-long forward calendar per city. Rows = cities x dates, one request each, so 1 city x 30 dates is 30 requests and roughly 2,500 rows for a big city.

## `dateStepDays` (type: `integer`):

1 = every day (a full calendar). 7 = same weekday each week, which is the cheap way to watch a long season without paying for every date.

## `guests` (type: `integer`):

Guest count the prices are quoted for. Dorm pricing barely moves with this; private-room pricing does.

## `nights` (type: `integer`):

Length of stay. This matters: length-of-stay promotions (promo type LOS) only appear at the night counts they apply to, so sweep the stay lengths your own guests actually book.

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

ISO code, e.g. EUR, USD, GBP. Leave empty to take Hostelworld's default for the city. Fixing one currency makes a multi-country comp set comparable.

## `deltaMode` (type: `boolean`):

Turn this on for a scheduled monitor. The first run records a baseline; every later run returns and bills ONLY cells that changed — price up or down, promo stack changed, organic position moved — plus properties that vanished from a date they were previously priced on, which is how sold-out shows up on this data (there is no availability flag). Unchanged cells are never charged, so a quiet day costs almost nothing.

## `deltaStateKey` (type: `string`):

Names an independent delta stream so several monitors don't collide (e.g. 'london-compset' vs 'iberia-summer'). Only used when Delta mode is on.

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

This data needs no proxy: it is served keyless to ordinary datacenter IPs, verified with 25 rapid requests and no throttling. Leave it off unless you specifically want your traffic routed. Turning it on costs proxy usage without improving results.

## Actor input object example

```json
{
  "mode": "rate_calendar",
  "cityIds": [
    "3",
    "20"
  ],
  "countryIds": [
    "237"
  ],
  "startDaysAhead": 1,
  "horizonDays": 30,
  "dateStepDays": 1,
  "guests": 2,
  "nights": 2,
  "currency": "EUR",
  "deltaMode": false,
  "deltaStateKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "mode": "rate_calendar",
    "cityIds": [
        "3"
    ],
    "countryIds": [
        "237"
    ],
    "startDaysAhead": 1,
    "horizonDays": 30,
    "dateStepDays": 1,
    "guests": 2,
    "nights": 2,
    "deltaStateKey": "default"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zhorex/hostelworld-rate-monitor").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 = {
    "mode": "rate_calendar",
    "cityIds": ["3"],
    "countryIds": ["237"],
    "startDaysAhead": 1,
    "horizonDays": 30,
    "dateStepDays": 1,
    "guests": 2,
    "nights": 2,
    "deltaStateKey": "default",
}

# Run the Actor and wait for it to finish
run = client.actor("zhorex/hostelworld-rate-monitor").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 '{
  "mode": "rate_calendar",
  "cityIds": [
    "3"
  ],
  "countryIds": [
    "237"
  ],
  "startDaysAhead": 1,
  "horizonDays": 30,
  "dateStepDays": 1,
  "guests": 2,
  "nights": 2,
  "deltaStateKey": "default"
}' |
apify call zhorex/hostelworld-rate-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hostelworld Rate & Availability Monitor",
        "description": "Forward-dated hostel rate calendar: price, dorm/private split, promo stack, organic ranking position and commission split per property per date. Delta mode returns only what moved. No login, no API key, no browser.",
        "version": "0.1",
        "x-build-id": "K6BbN94QEZ9r5jSi4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zhorex~hostelworld-rate-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zhorex-hostelworld-rate-monitor",
                "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/zhorex~hostelworld-rate-monitor/runs": {
            "post": {
                "operationId": "runs-sync-zhorex-hostelworld-rate-monitor",
                "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/zhorex~hostelworld-rate-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-zhorex-hostelworld-rate-monitor",
                "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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "rate_calendar",
                            "city_index"
                        ],
                        "type": "string",
                        "description": "'Rate calendar' builds the priced comp set: one row per property per arrival date per guest configuration, with price, promo stack, organic ranking position and Hostelworld's own commission split. 'City index' is the lookup utility — give it a country id and it returns that country's cities with their ids, so you can find the cityIds you need.",
                        "default": "rate_calendar"
                    },
                    "cityIds": {
                        "title": "City IDs",
                        "type": "array",
                        "description": "Hostelworld city ids to sweep. London = 3, Munich = 20. Don't know yours? Run mode 'City index' with a countryId first (England = 237). One request is issued per city per arrival date, and a whole city fits in a single request — London returns 83 properties at once.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "countryIds": {
                        "title": "Country IDs (city-index mode only)",
                        "type": "array",
                        "description": "Only used by 'City index' mode. England = 237. Returns each country's cities with ids and coordinates.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDaysAhead": {
                        "title": "First arrival date (days from today)",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "How far ahead the calendar starts. 1 = tomorrow. Rates for tonight behave differently from forward rates, so most comp-set work starts at 1 or 7.",
                        "default": 1
                    },
                    "horizonDays": {
                        "title": "Horizon (number of days to cover)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "How many arrival dates to price, counting from the first. 30 gives a month-long forward calendar per city. Rows = cities x dates, one request each, so 1 city x 30 dates is 30 requests and roughly 2,500 rows for a big city.",
                        "default": 30
                    },
                    "dateStepDays": {
                        "title": "Date step",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "1 = every day (a full calendar). 7 = same weekday each week, which is the cheap way to watch a long season without paying for every date.",
                        "default": 1
                    },
                    "guests": {
                        "title": "Guests",
                        "minimum": 1,
                        "maximum": 16,
                        "type": "integer",
                        "description": "Guest count the prices are quoted for. Dorm pricing barely moves with this; private-room pricing does.",
                        "default": 2
                    },
                    "nights": {
                        "title": "Nights",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Length of stay. This matters: length-of-stay promotions (promo type LOS) only appear at the night counts they apply to, so sweep the stay lengths your own guests actually book.",
                        "default": 2
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "ISO code, e.g. EUR, USD, GBP. Leave empty to take Hostelworld's default for the city. Fixing one currency makes a multi-country comp set comparable."
                    },
                    "deltaMode": {
                        "title": "Delta mode — only what MOVED since the last run",
                        "type": "boolean",
                        "description": "Turn this on for a scheduled monitor. The first run records a baseline; every later run returns and bills ONLY cells that changed — price up or down, promo stack changed, organic position moved — plus properties that vanished from a date they were previously priced on, which is how sold-out shows up on this data (there is no availability flag). Unchanged cells are never charged, so a quiet day costs almost nothing.",
                        "default": false
                    },
                    "deltaStateKey": {
                        "title": "Delta stream name",
                        "type": "string",
                        "description": "Names an independent delta stream so several monitors don't collide (e.g. 'london-compset' vs 'iberia-summer'). Only used when Delta mode is on.",
                        "default": "default"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy (optional — not required)",
                        "type": "object",
                        "description": "This data needs no proxy: it is served keyless to ordinary datacenter IPs, verified with 25 rapid requests and no throttling. Leave it off unless you specifically want your traffic routed. Turning it on costs proxy usage without improving results.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
