# Hostelworld Scraper (`solidcode/hostelworld-scraper`) Actor

\[💰 $2.5 / 1K] Extract Hostelworld hostel listings AND guest reviews in one run — prices, ratings, addresses, amenities, room types, plus per-property reviews with reviewer nationality and traveller type. Search by city or paste URLs.

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

## Pricing

from $4.00 / 1,000 listing 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

## Hostelworld Scraper

Pull hostel and budget-accommodation data from Hostelworld at scale — property names, live nightly prices, overall ratings with full sub-score breakdowns, exact coordinates, amenities, room types, images, and guest reviews tagged by reviewer nationality and traveller type. Search by plain city name or paste Hostelworld URLs, set your check-in dates, and get both listings and reviews in one structured dataset. Built for travel-market analysts, OTA and rate-intelligence teams, and hostel operators who need Hostelworld inventory plus guest sentiment without copy-pasting property pages by hand.

### Why This Scraper?

- **Guest reviews competitors don't return** — every review carries reviewer nationality, traveller type (solo / couple / group / family), age group, rating, body text, language, and review date, each joined back to its property by `listingId`.
- **Plain-language city search** — type "Lisbon" or "hostels in Bangkok" and get results; no hand-crafted search URLs required. Paste Hostelworld URLs instead when you want exact targeting.
- **Live nightly pricing for your dates** — pass `checkIn`, `checkOut`, and `guests` to price actual availability instead of catalog defaults, broken out as `priceFrom`, `priceFromDorm`, and `priceFromPrivate`.
- **Full rating breakdown, not just a score** — overall guest rating plus the count it's based on, a word label (Superb / Fabulous / Very Good), and seven sub-scores: security, location, staff, atmosphere, cleanliness, facilities, and value.
- **23 currencies and 17 languages** — price in USD, EUR, GBP, JPY, THB, BRL, and 18 more; localize property descriptions and review text into Spanish, German, Japanese, Chinese, and 13 others.
- **Precise location data** — latitude, longitude, district, city, and country on every property, ready to map or geo-filter.
- **Room-level detail** — `roomTypes` lists each dorm and private option with capacity, type, ensuite flag, and price, plus a flattened `amenities` list and a `freeCancellation` flag.
- **Two record types, one run** — `recordType: "listing"` and `recordType: "review"` share a single dataset, with separate Listings and Reviews views so you can export each cleanly.
- **Reviews are opt-in and bounded** — `maxReviewsPerListing` keeps cost predictable; leave it at 0 for a listings-only run, raise it only when you need sentiment data.

### Use Cases

**Travel Market Research**
- Map hostel inventory and price levels across backpacker cities worldwide
- Compare dorm vs. private pricing by destination and season
- Track which property types dominate a market (hostel, hotel, B&B, apartment)
- Benchmark amenities and free-cancellation availability across a city

**Rate & Competitive Intelligence**
- Monitor live nightly rates for your exact dates and guest counts
- Compare your property's price-from against nearby competitors
- Detect promoted and featured listings crowding the top of search
- Watch how sort order (popularity, price, rating) reshuffles a market

**Guest Sentiment Analysis**
- Mine review text for recurring complaints and praise per property
- Segment sentiment by reviewer nationality, traveller type, and age group
- Score competitor properties on the seven rating sub-categories
- Build language-specific review datasets for NLP and topic modeling

**Lead Generation for Suppliers**
- Build target lists of hostels by city, rating, or property type
- Identify under-reviewed or low-rated properties as outreach prospects
- Surface newly promoted listings investing in visibility

**Data Enrichment & Integration**
- Enrich an existing accommodation database with ratings and coordinates
- Feed pricing and sentiment into dashboards and market reports
- Power comparison tools with live multi-currency rates

### Getting Started

#### Search a City

The simplest run — just name a destination:

```json
{
    "search": "hostels in Lisbon",
    "maxResults": 50
}
````

#### Add Guest Reviews

Turn on reviews to capture sentiment alongside the listings:

```json
{
    "search": "Barcelona",
    "maxResults": 30,
    "maxReviewsPerListing": 25,
    "sortBy": "rating"
}
```

#### Live Pricing with Dates, Currency & Language

Price real availability for your stay and localize the output:

```json
{
    "search": "Bangkok",
    "checkIn": "2026-08-12",
    "checkOut": "2026-08-15",
    "guests": 3,
    "maxResults": 100,
    "maxReviewsPerListing": 50,
    "sortBy": "price_low",
    "currency": "EUR",
    "language": "es"
}
```

#### Using Hostelworld URLs

Paste search-result pages or individual property pages — the type is detected automatically:

```json
{
    "startUrls": [
        "https://www.hostelworld.com/pwa/s?id=Lisbon",
        "https://www.hostelworld.com/pwa/hosteldetails.php/p/p/12345"
    ],
    "maxReviewsPerListing": 20
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `search` | string | `"hostels in Lisbon"` | City, country, or area to search on Hostelworld in plain language — no URL needed. If you also paste URLs below, the URLs are used instead. |
| `startUrls` | string\[] | `[]` | Hostelworld URLs to scrape — search-result pages or individual property pages. The page type is detected automatically. Overrides the destination above. |

#### Dates & Guests

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `checkIn` | string | `null` | Check-in date in `YYYY-MM-DD` format. Provide it for live nightly prices and room availability; leave empty for catalog listing data. |
| `checkOut` | string | `null` | Check-out date in `YYYY-MM-DD` format. Must be after the check-in date. |
| `guests` | integer | `2` | Number of guests. Affects which rooms and prices Hostelworld shows. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of property listings to return. Set to 0 for all available. |
| `maxReviewsPerListing` | integer | `0` | How many guest reviews to also collect per property. 0 returns listings only (cheapest). Each review is its own result — popular hostels can have thousands, so start small. |
| `sortBy` | select | `Most popular` | How listings are ranked: Most popular, Price (lowest first), or Best rated. |

#### Localization

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `currency` | select | `US Dollar` | Currency for displayed prices. 23 options including US Dollar, Euro, British Pound, Japanese Yen, Thai Baht, and Brazilian Real. |
| `language` | select | `English` | Language for property descriptions and review text where available. 17 options including Spanish, French, German, Japanese, and Chinese (Simplified). |

### Output

Each row carries a `recordType` field — either `listing` or `review` — so both share one dataset. The Listings and Reviews views let you export each separately.

#### Listing Example

```json
{
    "recordType": "listing",
    "id": "12345",
    "name": "Sunset Backpackers Lisbon",
    "propertyType": "Hostel",
    "url": "https://www.hostelworld.com/pwa/hosteldetails.php/p/p/12345",
    "address": "Rua do Alecrim 12",
    "district": "Bairro Alto",
    "city": "Lisbon",
    "country": "Portugal",
    "latitude": 38.7101,
    "longitude": -9.1428,
    "overallRating": 9.2,
    "ratingsCount": 4187,
    "ratingLabel": "Superb",
    "ratingBreakdown": {
        "security": 9.1, "location": 9.6, "staff": 9.4,
        "atmosphere": 9.0, "cleanliness": 9.3, "facilities": 8.8, "value": 9.0
    },
    "priceFrom": 18.5,
    "priceFromDorm": 18.5,
    "priceFromPrivate": 62.0,
    "currency": "EUR",
    "roomTypes": [
        { "name": "6 Bed Mixed Dorm", "type": "dorm", "capacity": 6, "ensuite": false, "price": 18.5 }
    ],
    "amenities": ["Free WiFi", "24h Reception", "Bar", "Luggage Storage"],
    "images": ["https://www.hostelworld.com/.../photo1.jpg"],
    "freeCancellation": true,
    "isPromoted": false,
    "description": "A lively hostel in the heart of Bairro Alto...",
    "scrapedAt": "2026-06-11T14:30:00Z"
}
```

##### Core & Property

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"listing"` for these rows. |
| `id` | string | Hostelworld property ID. |
| `name` | string | Property name. |
| `propertyType` | string | Hostel, hotel, B\&B, apartment, etc. |
| `url` | string | Property page URL on Hostelworld. |
| `description` | string | Property overview text. |
| `images` | string\[] | Property image URLs. |
| `isPromoted` | boolean | Promoted or featured flag. |
| `freeCancellation` | boolean | Whether free cancellation is available. |
| `scrapedAt` | string | ISO 8601 timestamp of extraction. |

##### Location

| Field | Type | Description |
|-------|------|-------------|
| `address` | string | Street address. |
| `district` | string | Neighbourhood or district. |
| `city` | string | City. |
| `country` | string | Country. |
| `latitude` | number | Latitude. |
| `longitude` | number | Longitude. |

##### Pricing & Rooms

| Field | Type | Description |
|-------|------|-------------|
| `priceFrom` | number | Lowest nightly price available. |
| `priceFromDorm` | number | Lowest dorm bed price per night. |
| `priceFromPrivate` | number | Lowest private room price per night. |
| `currency` | string | Currency code of the prices. |
| `roomTypes` | object\[] | Room and bed options: name, type (dorm/private), capacity, ensuite, price. |
| `amenities` | string\[] | Facilities and amenities, flattened from Hostelworld's categories. |

##### Ratings

| Field | Type | Description |
|-------|------|-------------|
| `overallRating` | number | Overall guest score (e.g. 9.2). |
| `ratingsCount` | integer | Number of ratings the score is based on. |
| `ratingLabel` | string | Word label (Superb, Fabulous, Very Good, Good, Okay). |
| `ratingBreakdown` | object | Sub-scores: security, location, staff, atmosphere, cleanliness, facilities, value. |

#### Review Example

```json
{
    "recordType": "review",
    "listingId": "12345",
    "listingName": "Sunset Backpackers Lisbon",
    "listingUrl": "https://www.hostelworld.com/pwa/hosteldetails.php/p/p/12345",
    "reviewId": "98765432",
    "rating": 9.0,
    "text": "Great location and super friendly staff. The bar got busy at night but the dorms were quiet.",
    "authorName": "Marie",
    "authorCountry": "France",
    "authorAgeGroup": "25-30",
    "travellerType": "Solo female",
    "reviewDate": "2026-05-28",
    "language": "en"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"review"` for these rows. |
| `listingId` | string | Property ID this review belongs to (joins back to the listing). |
| `listingName` | string | Property name, so each review is useful standalone. |
| `listingUrl` | string | Property page URL. |
| `reviewId` | string | Review ID. |
| `rating` | number | Reviewer's overall score for the stay. |
| `text` | string | Review body text. |
| `authorName` | string | Reviewer display name. |
| `authorCountry` | string | Reviewer nationality / country. |
| `authorAgeGroup` | string | Reviewer age band, when shown. |
| `travellerType` | string | Solo, couple, group, family, etc. |
| `reviewDate` | string | When the review was posted (ISO 8601). |
| `language` | string | Language code of the review text. |

### Tips for Best Results

- **Start small to verify** — set `maxResults` to 10–30 on your first run to confirm the data matches your needs, then scale up.
- **Reviews are billed separately — turn them on only when you need sentiment** — leave `maxReviewsPerListing` at 0 for a pure listings run; a single popular hostel can have thousands of reviews, so set a modest cap like 25–50 to keep cost predictable. Up to 5,000 reviews per property are collected.
- **Pass dates for accurate prices** — without `checkIn`/`checkOut` you get catalog defaults; add your stay dates and guest count for true live nightly rates and room availability.
- **Match currency and language to your audience** — set `currency` and `language` up front so prices and review text arrive localized rather than needing post-processing.
- **Sort by rating for sentiment work** — `Best rated` surfaces the properties most worth analyzing first, while `Price (lowest first)` is ideal for budget benchmarking. Sort ranks the listings fetched for your `maxResults`, so for a true city-wide cheapest- or top-rated ranking, raise `maxResults` (or set it to 0) to pull the whole city before sorting.
- **City search or a property URL — both return full details** — a plain city name returns the full city catalog, and pasting an individual property page returns that one property's complete record (rating breakdown, price, amenities, images) plus its reviews. Typing a destination is the most reliable way to cover a whole market.
- **Join reviews to listings on `listingId`** — every review carries its property ID, name, and URL, so the two record types merge cleanly in any spreadsheet or database.

### Pricing

**From $4 per 1,000 listings + $1 per 1,000 reviews** (shown at the Gold loyalty tier; discount tiers below). No compute or time-based charges — you pay only per result, with listings and reviews priced separately, plus a small fixed per-run start fee.

Reviews are opt-in: a listings-only run (`maxReviewsPerListing` = 0) is charged for listings alone.

#### Listings Pricing

| Listings | No discount | Bronze | Silver | Gold |
|----------|-------------|--------|--------|------|
| 100 | $0.48 | $0.45 | $0.42 | $0.40 |
| 1,000 | $4.80 | $4.50 | $4.20 | $4.00 |
| 10,000 | $48.00 | $45.00 | $42.00 | $40.00 |
| 100,000 | $480.00 | $450.00 | $420.00 | $400.00 |

#### Reviews Pricing

| Reviews | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.12 | $0.11 | $0.105 | $0.10 |
| 1,000 | $1.20 | $1.10 | $1.05 | $1.00 |
| 10,000 | $12.00 | $11.00 | $10.50 | $10.00 |
| 100,000 | $120.00 | $110.00 | $105.00 | $100.00 |

#### Example Run Cost

Blended totals at the Gold tier so you can see the combined cost of a typical run:

| Run | Listings | Reviews | Total |
|-----|----------|---------|-------|
| Listings only | 200 | 0 | $0.80 |
| Light sentiment | 100 | 1,000 | $1.40 |
| Full sentiment sweep | 500 | 5,000 | $7.00 |

A "result" is any row in the output dataset — each listing and each review counts once. Platform fees (compute, storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate travel market research, rate analysis, and sentiment study. You are responsible for complying with applicable laws and Hostelworld's Terms of Service. Review text and reviewer details are personal data — handle them in line with GDPR and other privacy regulations, and do not use extracted data for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `search` (type: `string`):

City, country, or area to search on Hostelworld (e.g. 'Lisbon', 'hostels in Bangkok', 'Berlin'). Plain language — no URL needed. If you also paste URLs below, the URLs are used instead.

## `startUrls` (type: `array`):

Paste Hostelworld URLs to scrape — search-result pages or individual property pages. The actor detects the page type automatically: a search-result page returns that city's listings, and an individual property page returns that one property's full details (plus its reviews, if you turn them on). When provided, these override the destination above.

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

Check-in date in YYYY-MM-DD format. Optional — provide it to get live nightly prices and room availability. Leave empty for catalog listing data only.

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

Check-out date in YYYY-MM-DD format. Must be after the check-in date.

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

Number of guests. Affects which rooms and prices Hostelworld shows.

## `maxResults` (type: `integer`):

Maximum number of property listings to return. Set to 0 for all available.

## `maxReviewsPerListing` (type: `integer`):

How many guest reviews to also collect for each property. Set to 0 to skip reviews and return listings only (cheapest). Each review is returned as its own result and adds to your total — popular hostels can have thousands of reviews, so start small. Capped at 5,000 reviews per property to keep runs bounded.

## `sortBy` (type: `string`):

How Hostelworld should rank the listings.

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

Currency used for displayed prices.

## `language` (type: `string`):

Language for result text such as property descriptions and review text (where Hostelworld provides it).

## Actor input object example

```json
{
  "search": "hostels in Lisbon",
  "startUrls": [],
  "guests": 2,
  "maxResults": 100,
  "maxReviewsPerListing": 0,
  "sortBy": "popularity",
  "currency": "USD",
  "language": "en"
}
```

# Actor output Schema

## `listings` (type: `string`):

Hostel properties: name, price-from, rating, address, amenities, and room types.

## `reviews` (type: `string`):

Guest reviews per property: rating, text, reviewer country, and traveller type.

# 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 = {
    "search": "hostels in Lisbon",
    "startUrls": [],
    "guests": 2,
    "maxResults": 100,
    "maxReviewsPerListing": 0,
    "sortBy": "popularity",
    "currency": "USD",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "search": "hostels in Lisbon",
    "startUrls": [],
    "guests": 2,
    "maxResults": 100,
    "maxReviewsPerListing": 0,
    "sortBy": "popularity",
    "currency": "USD",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "search": "hostels in Lisbon",
  "startUrls": [],
  "guests": 2,
  "maxResults": 100,
  "maxReviewsPerListing": 0,
  "sortBy": "popularity",
  "currency": "USD",
  "language": "en"
}' |
apify call solidcode/hostelworld-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hostelworld Scraper",
        "description": "[💰 $2.5 / 1K] Extract Hostelworld hostel listings AND guest reviews in one run — prices, ratings, addresses, amenities, room types, plus per-property reviews with reviewer nationality and traveller type. Search by city or paste URLs.",
        "version": "1.0",
        "x-build-id": "brtYbth6h00mkC8ej"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~hostelworld-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~hostelworld-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~hostelworld-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": {
                    "search": {
                        "title": "Search",
                        "type": "string",
                        "description": "City, country, or area to search on Hostelworld (e.g. 'Lisbon', 'hostels in Bangkok', 'Berlin'). Plain language — no URL needed. If you also paste URLs below, the URLs are used instead."
                    },
                    "startUrls": {
                        "title": "Hostelworld URLs",
                        "type": "array",
                        "description": "Paste Hostelworld URLs to scrape — search-result pages or individual property pages. The actor detects the page type automatically: a search-result page returns that city's listings, and an individual property page returns that one property's full details (plus its reviews, if you turn them on). When provided, these override the destination above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkIn": {
                        "title": "Check-in Date",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format. Optional — provide it to get live nightly prices and room availability. Leave empty for catalog listing data only."
                    },
                    "checkOut": {
                        "title": "Check-out Date",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format. Must be after the check-in date."
                    },
                    "guests": {
                        "title": "Guests",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of guests. Affects which rooms and prices Hostelworld shows.",
                        "default": 2
                    },
                    "maxResults": {
                        "title": "Max Listings",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of property listings to return. Set to 0 for all available.",
                        "default": 100
                    },
                    "maxReviewsPerListing": {
                        "title": "Reviews per Listing",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How many guest reviews to also collect for each property. Set to 0 to skip reviews and return listings only (cheapest). Each review is returned as its own result and adds to your total — popular hostels can have thousands of reviews, so start small. Capped at 5,000 reviews per property to keep runs bounded.",
                        "default": 0
                    },
                    "sortBy": {
                        "title": "Sort Listings By",
                        "enum": [
                            "popularity",
                            "price_low",
                            "rating"
                        ],
                        "type": "string",
                        "description": "How Hostelworld should rank the listings.",
                        "default": "popularity"
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "AUD",
                            "CAD",
                            "NZD",
                            "JPY",
                            "CNY",
                            "CHF",
                            "SEK",
                            "NOK",
                            "DKK",
                            "PLN",
                            "BRL",
                            "MXN",
                            "INR",
                            "SGD",
                            "HKD",
                            "ZAR",
                            "AED",
                            "TRY",
                            "THB",
                            "IDR"
                        ],
                        "type": "string",
                        "description": "Currency used for displayed prices.",
                        "default": "USD"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "nl",
                            "pl",
                            "ja",
                            "ko",
                            "zh-CN",
                            "ru",
                            "sv",
                            "da",
                            "no",
                            "fi",
                            "tr"
                        ],
                        "type": "string",
                        "description": "Language for result text such as property descriptions and review text (where Hostelworld provides it).",
                        "default": "en"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
