# Hostelworld Guest Reviews Scraper (`automation-lab/hostelworld-guest-reviews-scraper`) Actor

Extract Hostelworld guest reviews, rating breakdowns, reviewer demographics, owner replies, and property context from public URLs or IDs.

- **URL**: https://apify.com/automation-lab/hostelworld-guest-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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 Guest Reviews Scraper

Collect structured public guest feedback from Hostelworld property URLs or numeric property IDs.

Hostelworld Guest Reviews Scraper turns review pages into analysis-ready rows with review text, stay dates, rating breakdowns, reviewer demographics, traveller context, owner replies, and property-level scores.

Use it for recurring reputation monitoring, sentiment analysis, competitor benchmarking, hospitality research, and customer-experience dashboards.

- 🏨 Target one or many public Hostelworld properties
- 💬 Save one clean dataset row per guest review
- ⭐ Compare overall, value, safety, location, staff, atmosphere, cleanliness, and facilities scores
- 🌍 Segment feedback by reviewer country, age band, traveller type, and trip type
- 📅 Limit scheduled runs to recent stays with an inclusive date cutoff
- 🔁 Avoid duplicate properties and review IDs inside each run
- ⚡ Use an HTTP-only workflow without a browser or login

### What does Hostelworld Guest Reviews Scraper do?

The Actor accepts standard Hostelworld property URLs such as:

`https://www.hostelworld.com/hostels/p/88047/wombat-s-city-hostel-london/`

It also accepts the numeric property ID `88047`, which is convenient for API clients and existing property databases.

For every selected property, the Actor retrieves public property context and walks the available newest-first review pages until it reaches your per-property cap, global cap, date cutoff, or the end of the source pagination.

Each result is independently useful because property context is repeated alongside the review.

You do not need a Hostelworld account, browser cookies, or a third-party data API.

### Who is this Hostelworld review extractor for?

#### Hostel operators and groups

Monitor new guest feedback across your own locations and compare recurring themes by property, month, traveller segment, or rating category.

#### Hospitality reputation platforms

Feed structured comments and owner replies into alerts, case-management tools, response queues, and customer-experience dashboards.

#### Travel-market analysts

Benchmark competing hostels by staff, cleanliness, atmosphere, location, safety, facilities, and value scores.

#### Agencies and consultants

Create repeatable reporting for hospitality clients without manually copying review cards into spreadsheets.

#### Data and machine-learning teams

Build language-aware corpora for sentiment classification, topic detection, summarization, and hospitality trend research.

### Why use this Actor?

- **Structured output:** get typed fields instead of brittle copied page text.
- **Review-level detail:** preserve full comments, category ratings, demographics, and replies.
- **Property context:** join review insights to names, locations, aggregate scores, and source URLs.
- **Predictable scope:** strict Hostelworld URL validation prevents accidental off-target crawling.
- **Cost control:** set both per-property and global review limits.
- **Incremental monitoring:** use `minStayDate` to focus a scheduled run on recent feedback.
- **Export flexibility:** download JSON, CSV, Excel, XML, or consume the dataset API.
- **Automation ready:** connect runs to schedules, webhooks, Make, Zapier, Sheets, or your own pipeline.

### What Hostelworld review data can I extract?

| Field group | Example fields | Use |
|---|---|---|
| Property | `propertyId`, `propertyName`, `propertyUrl` | Stable source identity |
| Location | `propertyCity`, `propertyCountry` | Market and geography analysis |
| Property rating | `propertyScore`, `propertyStaffScore`, `propertyCleanlinessScore` | Competitor benchmarking |
| Review identity | `reviewId`, `stayDate`, `stayMonth` | Deduplication and cohorts |
| Guest feedback | `reviewText`, `ownerReply` | Sentiment and response analysis |
| Review ratings | `reviewScore`, `reviewSafetyScore`, `reviewValueScore` | Category-level diagnostics |
| Reviewer | `reviewerName`, `reviewerCountry`, `reviewerAgeBand` | Audience segmentation |
| Travel context | `travellerType`, `tripTypes` | Solo, group, and trip analysis |
| Language | `languageCode`, `isMachineTranslated` | Translation-aware processing |
| Lineage | `sourceApiUrl`, `scrapedAt` | Auditing and freshness checks |

All displayed rating fields use a consistent 0–10 scale.

Optional source values are omitted when Hostelworld does not publish them for a review.

### How to scrape Hostelworld guest reviews

1. Open the Actor input page.
2. Paste one or more public Hostelworld property URLs, enter property IDs, or use both.
3. Set **Maximum reviews per property**.
4. Set the global **Maximum reviews for the run**.
5. Optionally enter an earliest stay date in `YYYY-MM-DD` format.
6. Click **Start**.
7. Open the dataset while the run is active or after it finishes.
8. Export the rows or connect the dataset to your downstream workflow.

For a cheap first test, keep the prefilled property and ten-review limits.

### Input parameters

#### `startUrls`

An array of public Hostelworld property pages.

Each URL must use `hostelworld.com` or one of its subdomains and contain `/p/{numeric-property-id}/`.

Search pages, city pages, unrelated domains, and malformed paths are rejected rather than silently broadened.

#### `propertyIds`

An array of numeric Hostelworld property IDs.

Duplicate IDs supplied through either input route are processed once.

#### `maxReviewsPerProperty`

Maximum newest reviews to save for each property.

Default: `20`.

Prefill: `10`.

#### `maxReviews`

Global safety cap across all supplied properties.

Default: `100`.

Prefill: `10`.

#### `minStayDate`

Optional inclusive cutoff in `YYYY-MM-DD` format.

A value of `2026-01-01` includes source records dated January 1, 2026 or later.

Invalid calendar dates fail closed before extraction begins.

### Example input

```json
{
  "startUrls": [
    {
      "url": "https://www.hostelworld.com/hostels/p/88047/wombat-s-city-hostel-london/"
    }
  ],
  "maxReviewsPerProperty": 20,
  "maxReviews": 20
}
````

Property-ID workflow:

```json
{
  "propertyIds": ["88047"],
  "maxReviewsPerProperty": 50,
  "maxReviews": 50,
  "minStayDate": "2026-01-01"
}
```

### Example output

```json
{
  "propertyId": "88047",
  "propertyName": "Wombat's City Hostel London",
  "propertyUrl": "https://www.hostelworld.com/hostels/p/88047/",
  "propertyCity": "London",
  "propertyCountry": "England",
  "availableReviewCount": 1544,
  "propertyScore": 9.1,
  "propertyStaffScore": 9.2,
  "reviewId": "16576987",
  "stayDate": "2026-07-17",
  "stayMonth": "2026-07",
  "reviewText": "Great hostel! ...",
  "reviewScore": 9.1,
  "reviewerName": "spendmoon7386",
  "reviewerCountry": "USA",
  "reviewerCountryCode": "US",
  "reviewerAgeBand": "31-40",
  "travellerType": "FEMALE",
  "tripTypes": ["REGULARVACATION"],
  "languageCode": "en",
  "isMachineTranslated": true,
  "sourceApiUrl": "https://api.m.hostelworld.com/2.2/properties/88047/reviews?page=1&per-page=10&sort=-date",
  "scrapedAt": "2026-07-20T00:00:00.000Z"
}
```

Values change as guests publish reviews and Hostelworld updates its public data.

### How much does it cost to scrape Hostelworld reviews?

This Actor uses pay-per-event pricing.

A small one-time start event covers run setup, then each saved guest review triggers one review event.

The launch configuration is a `$0.005` start and `$0.000046602` per review on the BRONZE tier, with lower per-review rates on higher Apify tiers.

The live prices shown in the Apify pricing tab are authoritative.

Examples at the BRONZE configuration:

- 10 reviews: about `$0.00547`
- 100 reviews: about `$0.00966`
- 1,000 reviews: about `$0.05160`

Apify Free Plan users can test the prefilled ten-review workflow within normal platform credits.

Set conservative caps on scheduled runs so billing reflects the amount of history you actually need.

### Review-monitoring workflow

Run the Actor daily or weekly with the same property list.

Set `minStayDate` to the beginning of your monitoring window.

Store `propertyId + reviewId` in your destination as the durable unique key.

Upsert rows rather than blindly appending them when your destination supports it.

Trigger alerts for:

- low `reviewScore` values;
- drops in cleanliness or staff ratings;
- specific complaint topics;
- new owner replies;
- reviews from priority markets;
- changes in traveller mix.

### Tips for reliable extraction

- Start with one property and ten reviews.
- Use numeric IDs when your system already stores Hostelworld entities.
- Keep the global cap below the sum of per-property caps if you want a hard budget ceiling.
- Use recent date cutoffs for frequent scheduled monitoring.
- Use a larger cap only when building historical datasets.
- Keep raw `reviewText` for future reprocessing.
- Use `languageCode` and `isMachineTranslated` when evaluating text quality.
- Treat missing demographics as unavailable source data, not an extraction error.
- Inspect Actor logs when an individual property is skipped.

### Integrations

#### Google Sheets

Export the dataset as CSV or use the Apify Google Sheets integration to maintain a review-monitoring workbook.

#### Make

Schedule the Actor, iterate new dataset rows, classify sentiment, and route negative feedback to a team channel.

#### Zapier

Trigger a run from a workflow and send selected review records to a CRM, help desk, or notification service.

#### Slack or Microsoft Teams

Use a webhook integration to post reviews below a chosen rating threshold.

#### Airtable

Use `propertyId` and `reviewId` as keys for a searchable reputation database.

#### Data warehouses

Load JSON or CSV into BigQuery, Snowflake, Redshift, or PostgreSQL for longitudinal analysis.

### Use with the Apify API in JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/hostelworld-guest-reviews-scraper').call({
  propertyIds: ['88047'],
  maxReviewsPerProperty: 20,
  maxReviews: 20,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Install the client with `npm install apify-client`.

### Use with the Apify API in Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/hostelworld-guest-reviews-scraper').call(run_input={
    'propertyIds': ['88047'],
    'maxReviewsPerProperty': 20,
    'maxReviews': 20,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

Install the client with `pip install apify-client`.

### Use with cURL

Start a run:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~hostelworld-guest-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"propertyIds":["88047"],"maxReviewsPerProperty":10,"maxReviews":10}'
```

Fetch dataset items after the run succeeds:

```bash
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json&token=$APIFY_TOKEN"
```

Keep tokens in environment variables rather than source code.

### Use Hostelworld reviews with Apify MCP

Connect the Actor to AI assistants through Apify MCP.

Claude Code setup:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/hostelworld-guest-reviews-scraper"
```

Claude Desktop, Cursor, or VS Code configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/hostelworld-guest-reviews-scraper"
    }
  }
}
```

Example prompts:

- “Collect the ten newest reviews for Hostelworld property 88047 and summarize cleanliness complaints.”
- “Compare staff and atmosphere scores across these Hostelworld property URLs.”
- “Find recent reviews below 7.0 and format an operations alert.”
- “Group reviewer comments by country and traveller type.”

### Scheduling and incremental collection

Create an Apify schedule for daily, weekly, or monthly monitoring.

Use a rolling `minStayDate` appropriate to your cadence.

Send completed-run webhooks to your ingestion service.

Persist review IDs in your destination to avoid duplicates across separate runs.

The Actor deduplicates within one run; cross-run deduplication belongs in the destination because each dataset is intentionally independent.

### Limitations

- The Actor collects public records exposed by Hostelworld at run time.
- The API-visible historical count can differ from the total count shown elsewhere on a property page.
- Hostelworld can modify fields, pagination, availability, or access without notice.
- Some reviews omit gender, owner replies, or other optional profile details.
- Machine-translated text may differ from the original guest wording.
- Source dates are exposed as stay/review dates by Hostelworld; use them consistently rather than inferring booking dates.
- This Actor does not discover properties by city or availability.
- This Actor does not scrape prices, rooms, images, or booking availability.
- A property removed from the public source cannot be extracted.

### Is it legal to scrape Hostelworld reviews?

Public web data can still include personal information and copyrighted text.

Use the Actor only for legitimate purposes and collect no more data than your workflow needs.

Review Hostelworld's terms, applicable database and copyright rules, privacy laws, and your organization's compliance requirements.

Do not use results for harassment, discrimination, identity profiling, or decisions that unfairly affect individuals.

Respect deletion and correction requests where they apply to your processing.

This page is general information, not legal advice.

### Troubleshooting

#### “Could not find a numeric Hostelworld property ID”

Use a direct property page whose path contains `/p/12345/`, or enter `12345` in `propertyIds`.

City, search, and blog URLs are outside this Actor's scope.

#### The run returned fewer reviews than my cap

The cap is a maximum, not a promise.

The property may expose fewer reviews through the current public API, your `minStayDate` may exclude older records, or the global cap may have been reached first.

#### A demographic field is missing

Hostelworld does not publish every optional field for every reviewer.

The Actor omits unavailable values instead of inventing them.

#### One property failed but others completed

Check the logs for the rejected ID or upstream HTTP response.

The Actor isolates property-level failures and fails the whole run only when no supplied property can be processed.

### Frequently asked questions

#### Can I scrape multiple Hostelworld properties in one run?

Yes. Supply multiple URLs, IDs, or both, and set a global review cap.

#### Can I collect only recent reviews?

Yes. Set `minStayDate` to an inclusive `YYYY-MM-DD` boundary.

#### Does the Actor include owner responses?

Yes, when Hostelworld publishes an owner comment for the review.

#### Are ratings numbers or strings?

Ratings are numbers on a consistent 0–10 scale.

#### Does it need a proxy?

The initial implementation uses an anonymous first-party public JSON surface and does not require a proxy.

#### Does it scrape private accounts or bookings?

No. It processes public property and guest-review data only.

#### Can I export to Excel?

Yes. Open the dataset and choose Excel, CSV, JSON, XML, or another supported format.

### Related travel scrapers

- [Booking.com Scraper](https://apify.com/automation-lab/booking-scraper) — collect accommodation listings, prices, availability, and rating summaries.
- [Google Hotels Scraper](https://apify.com/automation-lab/google-hotels-scraper) — compare hotel search results and market visibility.
- [Tripadvisor Scraper](https://apify.com/automation-lab/tripadvisor-scraper) — expand review and attraction research to Tripadvisor.

Use this Actor when your primary entity is a Hostelworld guest review.

Choose a listing or hotel-search Actor when you need discovery, rates, rooms, or availability instead.

### Data retention and privacy

Apify stores run input and output according to your platform account and storage settings.

Use named storage or export results before automatic retention expires when building long-lived datasets.

Restrict dataset access when review text or reviewer profile details are sensitive in your context.

Delete source data that your organization no longer needs.

Keep credentials and API tokens outside input payloads.

### Support

If a valid public property suddenly produces no records:

1. confirm the property still opens publicly;
2. retry with a small cap;
3. inspect the Actor log;
4. include the run ID and property URL when reporting an issue.

A reproducible run ID helps distinguish invalid input, unavailable source data, and an upstream site change.

# Actor input Schema

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

Paste public Hostelworld property pages. Each URL must contain a numeric property ID in /p/ID/. You can use this field together with property IDs.

## `propertyIds` (type: `array`):

Enter numeric Hostelworld property IDs, such as 88047. Duplicate IDs and URLs are fetched only once.

## `maxReviewsPerProperty` (type: `integer`):

Stop after saving this many newest reviews for each property.

## `maxReviews` (type: `integer`):

Global safety cap across all properties. The run stops when this many review rows have been saved.

## `minStayDate` (type: `string`):

Optional inclusive cutoff in YYYY-MM-DD format. Reviews older than this date are skipped, which is useful for recurring monitoring.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.hostelworld.com/hostels/p/88047/wombat-s-city-hostel-london/"
    }
  ],
  "maxReviewsPerProperty": 10,
  "maxReviews": 10,
  "minStayDate": "2026-01-01"
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://www.hostelworld.com/hostels/p/88047/wombat-s-city-hostel-london/"
        }
    ],
    "maxReviewsPerProperty": 10,
    "maxReviews": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hostelworld-guest-reviews-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 = {
    "startUrls": [{ "url": "https://www.hostelworld.com/hostels/p/88047/wombat-s-city-hostel-london/" }],
    "maxReviewsPerProperty": 10,
    "maxReviews": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hostelworld-guest-reviews-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 '{
  "startUrls": [
    {
      "url": "https://www.hostelworld.com/hostels/p/88047/wombat-s-city-hostel-london/"
    }
  ],
  "maxReviewsPerProperty": 10,
  "maxReviews": 10
}' |
apify call automation-lab/hostelworld-guest-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hostelworld Guest Reviews Scraper",
        "description": "Extract Hostelworld guest reviews, rating breakdowns, reviewer demographics, owner replies, and property context from public URLs or IDs.",
        "version": "0.1",
        "x-build-id": "AUNYUqjsOSjAQMClE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~hostelworld-guest-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-hostelworld-guest-reviews-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/automation-lab~hostelworld-guest-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-hostelworld-guest-reviews-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/automation-lab~hostelworld-guest-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-hostelworld-guest-reviews-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": {
                    "startUrls": {
                        "title": "Hostelworld property URLs",
                        "type": "array",
                        "description": "Paste public Hostelworld property pages. Each URL must contain a numeric property ID in /p/ID/. You can use this field together with property IDs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "propertyIds": {
                        "title": "Hostelworld property IDs",
                        "type": "array",
                        "description": "Enter numeric Hostelworld property IDs, such as 88047. Duplicate IDs and URLs are fetched only once.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\d+$"
                        }
                    },
                    "maxReviewsPerProperty": {
                        "title": "Maximum reviews per property",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after saving this many newest reviews for each property.",
                        "default": 20
                    },
                    "maxReviews": {
                        "title": "Maximum reviews for the run",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Global safety cap across all properties. The run stops when this many review rows have been saved.",
                        "default": 100
                    },
                    "minStayDate": {
                        "title": "Earliest stay date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive cutoff in YYYY-MM-DD format. Reviews older than this date are skipped, which is useful for recurring monitoring."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```