# Hostelworld Hostel & Budget Accommodation Scraper (`parseforge/hostelworld-scraper`) Actor

Scrape hostel and budget accommodation listings from Hostelworld by city and country. Exports name, type, rating, reviews, price, location, and more.

- **URL**: https://apify.com/parseforge/hostelworld-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Travel, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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.
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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🏨 Hostelworld Scraper

> 🚀 **Export hostel and budget accommodation listings from Hostelworld in seconds.** Get names, ratings, reviews, prices, addresses, and images - no account needed.

> 🕒 **Last updated:** 2026-05-21 · **📊 13 fields** per record · **312+ hostels per city** · **Worldwide coverage**

The Hostelworld Scraper extracts hostel and budget accommodation listings from Hostelworld.com - the world's largest hostel booking platform with over 36,000 properties across 180+ countries. Data is scraped in real-time from live property pages so you always get current ratings, reviews, and prices.

Each record includes the property image, name, type, rating, review count, minimum nightly price, currency, city, country, full address, and direct listing URL.

**Coverage:** 180+ countries, 36,000+ hostels, guesthouses, and budget hotels. For any city supported by Hostelworld - Bangkok, Paris, Amsterdam, Tokyo, New York, Sydney, and thousands more.

| Who uses this | What they build |
|---|---|
| Travel platforms | Hostel comparison tools and budget travel apps |
| Data analysts | Price tracking and destination popularity studies |
| Researchers | Accommodation market analysis and tourism research |
| Marketers | Competitive intelligence for hospitality businesses |

### 📋 What the Hostelworld Scraper does

- Searches any city and country available on Hostelworld
- Scrapes all listed hostels, hotels, guesthouses, and budget accommodations
- Exports names, types, ratings, review counts, minimum prices, and addresses
- Paginates through all results automatically (30 per page, up to hundreds per city)
- Returns clean image URLs, direct listing links, and structured location data

> 💡 **Why it matters:** Hostelworld is the definitive source for budget travel accommodations worldwide. There is no public API - this scraper gives you programmatic access to a dataset that would take weeks to collect manually.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| maxItems | integer | 10 | Maximum number of listings to return |
| city | string | Bangkok | City name (e.g. Paris, Amsterdam, Tokyo) |
| country | string | Thailand | Country name (e.g. France, Netherlands, Japan) |
| checkIn | string | - | Optional check-in date (YYYY-MM-DD) |
| checkOut | string | - | Optional check-out date (YYYY-MM-DD) |

**Example - Bangkok hostels:**
```json
{
  "maxItems": 50,
  "city": "Bangkok",
  "country": "Thailand"
}
````

**Example - Paris with dates:**

```json
{
  "maxItems": 100,
  "city": "Paris",
  "country": "France",
  "checkIn": "2026-07-01",
  "checkOut": "2026-07-05"
}
```

> ⚠️ **Good to Know:** Free accounts are limited to 10 items as a preview. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to unlock up to 1,000,000 items.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 🖼️ imageUrl | string | Main listing photo URL |
| 🏨 name | string | Property name |
| 🏷️ type | string | Type: HOSTEL, HOTEL, GUESTHOUSE, etc. |
| ⭐ rating | number | Average guest rating out of 10 |
| 📝 reviewCount | integer | Total number of guest reviews |
| 💰 pricePerNight | number | Minimum price per night |
| 💵 currency | string | Currency code (USD) |
| 🏙️ city | string | City name |
| 🌍 country | string | Country name |
| 📍 address | string | Full street address |
| 🔗 url | string | Hostelworld listing URL |
| 🕒 scrapedAt | string | ISO 8601 timestamp of scrape |
| ❌ error | string | Error message if scraping failed |

**Sample record:**

```json
{
  "imageUrl": "https://a.hwstatic.com/image/upload/f_auto,q_auto,t_40/propertyimages/3/337829/wb2ofaxqw67jgqzczjgv.jpg",
  "name": "Nomads Bangkok Khao San Road Hostel",
  "type": "HOSTEL",
  "rating": 9.9,
  "reviewCount": 129,
  "pricePerNight": 8.66,
  "currency": "USD",
  "city": "Bangkok",
  "country": "Thailand",
  "address": "104/1 Soi Rambutri, Talat Yot Subdistrict, Phra Nakhon District, Bangkok",
  "url": "https://www.hostelworld.com/hosteldetails.php/nomads-bangkok-khao-san-road-hostel/bangkok/337829",
  "scrapedAt": "2026-05-21T23:31:05.984Z",
  "error": null
}
```

```json
{
  "imageUrl": "https://a.hwstatic.com/image/upload/f_auto,q_auto,t_40/propertyimages/3/315033/tfvlhhzkgfnxk8nwuwyy.jpg",
  "name": "Khao San Social Capsule Hostel",
  "type": "HOSTEL",
  "rating": 9.62,
  "reviewCount": 1699,
  "pricePerNight": 13.13,
  "currency": "USD",
  "city": "Bangkok",
  "country": "Thailand",
  "address": "147/14 Thanon Tani Talad Yod Phra Nakhorn",
  "url": "https://www.hostelworld.com/hosteldetails.php/khao-san-social-capsule-hostel/bangkok/315033",
  "scrapedAt": "2026-05-21T23:31:05.984Z",
  "error": null
}
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🌍 Worldwide coverage | Any city on Hostelworld - 180+ countries |
| 🔄 Real-time data | Scraped live, not cached |
| 📄 Full pagination | Automatically collects all pages of results |
| 💰 Price data | Minimum nightly prices with currency |
| ⭐ Ratings + reviews | Both numeric rating and review count |
| 📍 Full addresses | Street-level location for every property |
| 🖼️ Image URLs | Direct CDN links for property photos |
| 🏷️ Property types | Distinguishes HOSTEL, HOTEL, GUESTHOUSE, etc. |

### 📈 How it compares to alternatives

| Method | Speed | Cost | Coverage | Ease |
|---|---|---|---|---|
| Manual browsing | Very slow | Free | One city at a time | Hard |
| Hostelworld website | Slow | Free | Manual | Manual |
| This Actor | Fast | Pay-per-use | Any city, worldwide | One click |
| Custom scraper | Developer time | High dev cost | Limited | Very hard |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Find the Hostelworld Scraper in the Apify Store
3. Set your city (e.g. "Amsterdam") and country (e.g. "Netherlands")
4. Set maxItems to control how many results you want
5. Click "Run" and download your dataset as JSON, CSV, Excel, or XML

### 💼 Business use cases

#### Travel Platform Development

Build hostel search engines, budget travel comparison sites, or destination guides. The full dataset gives you structured accommodation data for any city without maintaining a Hostelworld account or scraping infrastructure.

#### Price Intelligence

Track minimum nightly prices across multiple cities to understand budget travel market dynamics. Identify price trends, seasonal variations, and competitive positioning.

#### Travel Research and Analytics

Analyze hostel density, rating distributions, and review counts by city to understand budget accommodation supply in different markets. Useful for tourism boards, hospitality researchers, and market analysts.

#### Marketing and Content

Generate location-specific content about budget travel options, enrich travel guides with current pricing data, or build email campaigns around hostel availability.

### 🔌 Automating Hostelworld Scraper

Connect Hostelworld Scraper to your tools using Apify integrations:

- **Make (Integromat):** Trigger a scrape on schedule and send results to Google Sheets or Airtable
- **Zapier:** Pipe new hostel data into Slack, Notion, or any 5,000+ apps
- **Webhooks:** POST results to your API endpoint when a run completes
- **Apify API:** Trigger runs programmatically and fetch data in real time
- **Slack alerts:** Get notified when price thresholds change for a city

### 🌟 Beyond business use cases

#### Academic Research

Study the global distribution of budget accommodations, pricing patterns across regions, and the relationship between tourism infrastructure and hostel density.

#### Personal Travel Planning

Export hostel data for a planned destination, sort by rating or price, and build your own shortlist - all without clicking through dozens of pages.

#### Non-profit and NGO Work

Organizations working in budget travel, youth tourism, or hospitality development can benchmark accommodation options in target regions.

#### Developer Experimentation

Use the structured dataset to prototype travel apps, test recommendation algorithms, or experiment with hospitality data visualizations.

### 🤖 Ask an AI assistant about this scraper

Not sure if this is the right tool? Drop this URL into ChatGPT, Claude, or Gemini and ask:

> "Does the Hostelworld Scraper on Apify extract the data I need for \[your use case]?"

### ❓ Frequently Asked Questions

**What cities does this scraper support?**
Any city available on Hostelworld - covering 180+ countries worldwide. If Hostelworld has listings for it, this scraper can collect them.

**How many properties can I scrape per city?**
Bangkok has 312+ properties. Popular cities like Paris, Amsterdam, and Barcelona have hundreds. All pages are automatically paginated.

**Is the data real-time or cached?**
All data is scraped live in real-time. No cached responses - you always get current ratings, prices, and availability.

**What property types are included?**
HOSTEL, HOTEL, GUESTHOUSE, and other budget accommodation types that Hostelworld lists. The `type` field tells you exactly which category each property is.

**Do prices include all fees?**
The `pricePerNight` is the minimum advertised price from Hostelworld for either a dorm bed or private room. Final booking prices may vary.

**Can I filter by dates?**
Yes - optionally provide `checkIn` and `checkOut` dates in YYYY-MM-DD format to filter results by availability.

**How long does a full city scrape take?**
Bangkok (312 properties, 11 pages) takes approximately 25-35 seconds. Most cities complete in under a minute.

**What does the free tier get me?**
Free users get 10 items as a preview of the data quality. [Upgrade to a paid plan](https://console.apify.com/sign-up?fpr=vmoqkp) for full city coverage.

**Can I scrape multiple cities in one run?**
Currently one city per run. Run the Actor multiple times with different city inputs, or use the Apify API to orchestrate multi-city scrapes programmatically.

**Is this scraper maintained?**
Yes - actively maintained. The `Last updated` date at the top of this README is bumped on every update.

### 🔌 Integrate with any app

Export your dataset in JSON, CSV, Excel, XML, RSS, JSONL. Use the Apify API to:

- Fetch data via REST endpoints
- Integrate with Make, Zapier, n8n, and 5,000+ apps
- Trigger runs from your backend and retrieve results programmatically
- Store datasets long-term with Apify Storage

[View the full API docs](https://docs.apify.com/api/v2)

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Booking.com Scraper](https://apify.com/parseforge) | Scrape hotel listings from Booking.com |
| [TripAdvisor Hotel Scraper](https://apify.com/parseforge) | Extract hotel reviews and ratings from TripAdvisor |
| [Airbnb Scraper](https://apify.com/parseforge) | Scrape short-term rental listings from Airbnb |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more travel, hospitality, and data scrapers built by the same team.

***

**Disclaimer:** This Actor is not affiliated with, endorsed by, or sponsored by Hostelworld Group Limited. All trademarks belong to their respective owners. Use responsibly and in accordance with Hostelworld's Terms of Service.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `city` (type: `string`):

City to search for hostels and budget accommodations (e.g. Bangkok, Paris, Amsterdam, Tokyo).

## `country` (type: `string`):

Country where the city is located (e.g. Thailand, France, Netherlands, Japan).

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

Optional check-in date in YYYY-MM-DD format. Leave blank for availability-independent results.

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

Optional check-out date in YYYY-MM-DD format.

## Actor input object example

```json
{
  "maxItems": 10,
  "city": "Bangkok",
  "country": "Thailand"
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10,
    "city": "Bangkok",
    "country": "Thailand"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/hostelworld-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 = {
    "maxItems": 10,
    "city": "Bangkok",
    "country": "Thailand",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/hostelworld-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 '{
  "maxItems": 10,
  "city": "Bangkok",
  "country": "Thailand"
}' |
apify call parseforge/hostelworld-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hostelworld Hostel & Budget Accommodation Scraper",
        "description": "Scrape hostel and budget accommodation listings from Hostelworld by city and country. Exports name, type, rating, reviews, price, location, and more.",
        "version": "0.1",
        "x-build-id": "gOFi0MKqhQgLAZDeP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~hostelworld-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-hostelworld-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/parseforge~hostelworld-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-hostelworld-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/parseforge~hostelworld-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-hostelworld-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "City to search for hostels and budget accommodations (e.g. Bangkok, Paris, Amsterdam, Tokyo)."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country where the city is located (e.g. Thailand, France, Netherlands, Japan)."
                    },
                    "checkIn": {
                        "title": "Check-in Date",
                        "type": "string",
                        "description": "Optional check-in date in YYYY-MM-DD format. Leave blank for availability-independent results."
                    },
                    "checkOut": {
                        "title": "Check-out Date",
                        "type": "string",
                        "description": "Optional check-out date in YYYY-MM-DD format."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
