# Hostelz Scraper | Hostel Listings and Prices (`parseforge/hostelz-scraper`) Actor

Scrape hostel data from Hostelz including names, prices, ratings, locations, amenities, room types, reviews and availability. Build accommodation datasets for travel comparison, budget trip planning and hospitality market research projects at scale across the full catalog

- **URL**: https://apify.com/parseforge/hostelz-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Travel, E-commerce, Other
- **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)

## 🏨 Hostelz.com Hostel Scraper

> 🚀 **Export global hostel listings with ratings, prices, and amenities in seconds.** No login required - just enter a city or country and get structured hostel data instantly.

> 🕒 **Last updated:** 2026-05-22 · **📊 12 fields** per record · **55+ hostels per city** · **Global coverage**

The Hostelz.com Hostel Scraper extracts real-time hostel listings from [Hostelz.com](https://www.hostelz.com), one of the world's leading hostel price comparison platforms. Simply enter a city or country name and get structured hostel data including ratings, pricing, amenities, and location details.

This scraper works across all regions - Europe, Asia, Americas, Africa, and Oceania - giving you a global dataset of budget accommodation options.

**Coverage:** 50+ countries, thousands of cities, 100,000+ hostel listings available, 12 data fields per record.

**Target Audience / Use Cases**

| Audience | Use Case |
|---|---|
| Travel apps & platforms | Enrich hostel search results with real-time pricing |
| Backpacker communities | Track hostel ratings and amenities globally |
| Travel market researchers | Analyze hostel pricing trends across destinations |
| Price comparison tools | Build hostel price intelligence datasets |

### 📋 What the Hostelz.com Scraper does

- Resolves any city or country name to its Hostelz.com listing page
- Extracts up to 55 hostels per city page (or more for country pages)
- Collects rating, review count, price, distance, and amenities for each hostel
- Visits each hostel detail page to retrieve the full amenity list
- Outputs clean JSON ready for analysis, import, or API use

> 💡 **Why it matters:** Hostelz.com aggregates prices from Hostelworld, Booking.com, and other platforms. This scraper captures that aggregated intelligence in one structured dataset.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchLocation` | string | `Barcelona` | City or country to search (e.g. Barcelona, Thailand, Germany) |
| `maxItems` | integer | `10` | Max number of hostels to return (free: 10, paid: up to 1,000,000) |

**Example - City search:**
```json
{
  "searchLocation": "Bangkok",
  "maxItems": 50
}
````

**Example - Country search:**

```json
{
  "searchLocation": "Portugal",
  "maxItems": 100
}
```

> ⚠️ **Good to Know:** Free users are limited to 10 hostels per run. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) to get started with a paid plan for full access.

### 📊 Output

Each hostel record contains:

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | Main hostel image URL |
| 🏨 `name` | string | Hostel name |
| 🔗 `url` | string | Hostelz.com listing URL |
| 🏙️ `city` | string | City name |
| 🌍 `country` | string | Country name |
| ⭐ `rating` | float | Combined rating (0-10) |
| 💬 `numReviews` | integer | Total number of reviews |
| 💰 `priceFrom` | float | Lowest nightly price (dorm bed) |
| 💱 `currency` | string | Currency symbol (€, $, etc.) |
| 📍 `distance` | float | Distance from city center in km |
| 🛎️ `amenities` | array | Available amenities list |
| 📅 `bookingUrl` | string | External booking link (if available) |
| 🕒 `scrapedAt` | string | ISO timestamp |
| ❌ `error` | string | Error message (if any) |

**Sample record:**

```json
{
  "imageUrl": "https://www.hostelz.com/pics/imported/listings/big/3/5349303.jpg",
  "name": "Onefam Paralelo",
  "url": "https://www.hostelz.com/hostel/197439-Onefam-Paralelo",
  "city": "Barcelona",
  "country": "Spain",
  "rating": 9.7,
  "numReviews": 9448,
  "priceFrom": 14.80,
  "currency": "€",
  "distance": 1.92,
  "amenities": [
    "Bedsheets",
    "Wi-Fi in Lobby/Commons",
    "24 Hour Security",
    "Air Conditioning",
    "BBQ Grill",
    "Kitchen",
    "Laundry",
    "Walking Tours"
  ],
  "bookingUrl": null,
  "scrapedAt": "2026-05-22T02:25:05.577Z"
}
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---|---|
| 🌍 Global coverage | Works for any city or country worldwide |
| ⭐ Rich data | Rating, reviews, price, distance, amenities in one record |
| 🚀 Fast extraction | 55+ hostels scraped in under 30 seconds |
| 🛎️ Full amenity list | Detail page visited for complete amenity data |
| 🔒 No login needed | Fully public data, no credentials required |
| 💰 Price-per-event | Only pay for what you actually collect |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | Other actors |
|---|---|---|---|
| Global coverage | Yes | Time-consuming | Varies |
| Amenity extraction | Full list | Partial | Rarely |
| Rating + reviews | Yes | Yes | Sometimes |
| Price data | Yes | Yes | Sometimes |
| City/country search | Yes | Manual navigation | Sometimes |
| Maintenance | Ongoing | DIY | Varies |

### 🚀 How to use

1. Open the actor on [Apify](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Enter a `searchLocation` (city or country name)
3. Set `maxItems` for how many hostels you need
4. Click **Run** and wait for results
5. Download as JSON, CSV, or Excel

### 💼 Business use cases

#### Travel App Development

Build hostel search features with real-time pricing and ratings. Compare hostels across neighborhoods and filter by amenities.

#### Market Research

Track hostel pricing trends across destinations. Identify which cities have the most budget-friendly options. Monitor seasonal pricing patterns.

#### Price Comparison Tools

Aggregate hostel data from Hostelz.com alongside other sources. Help travelers find the best deals on dorm beds globally.

#### Backpacker Community Platforms

Power recommendation engines with real rating and review data. Surface top-rated hostels by city for community guides.

### 🔌 Automating Hostelz.com Scraper

Connect this actor to your workflows using:

- **Make (formerly Integromat)** - Schedule runs and push data to Google Sheets, Airtable, or CRM
- **Zapier** - Trigger downstream workflows when new hostel data is collected
- **Apify API** - Integrate directly with your backend via REST API
- **Webhooks** - Get notified when runs complete

### 🌟 Beyond business use cases

#### Research & Academia

Study the global backpacker accommodation market. Analyze how hostel density correlates with tourism arrivals.

#### Creative Projects

Build travel budget calculators using real hostel pricing data. Create city guides ranked by hostel quality scores.

#### Non-profit Travel

Help budget travelers and NGO field workers find affordable accommodation worldwide.

#### Personal Travel Planning

Export hostel data for your next destination and plan your accommodation budget before you travel.

### 🤖 Ask an AI assistant about this scraper

You can ask ChatGPT, Claude, or any AI assistant:

> "I have hostel data from Hostelz.com with fields: name, city, country, rating, numReviews, priceFrom, currency, distance, amenities. How do I find the top 10 rated hostels under €15/night in Spain?"

### ❓ Frequently Asked Questions

**❓ What cities and countries does this support?**
Any city or country listed on Hostelz.com - that's thousands of destinations globally.

**❓ How many hostels can I get per run?**
Up to 55 hostels per city page. Country pages may have more. Use `maxItems` to control the limit.

**❓ Does it require login or API keys?**
No. All data is publicly available on Hostelz.com.

**❓ How fresh is the data?**
Data is scraped in real-time on every run - no cached responses.

**❓ What does "priceFrom" represent?**
The lowest available dorm bed price shown on Hostelz.com at the time of scraping.

**❓ Why is `bookingUrl` null?**
Hostelz.com uses redirect links for bookings. External booking URLs are not directly exposed in the page HTML.

**❓ How do I search for hostels in a specific neighborhood?**
Enter the city name. The scraper returns all hostels in that city with their distance from the city center.

**❓ Can I get hostels for an entire country?**
Yes. Enter the country name (e.g. "Germany") and the scraper will return hostels from the country listing page.

**❓ What amenities does the scraper capture?**
All amenities listed on the hostel detail page: WiFi, Kitchen, Laundry, Bar, Pool, 24hr Security, and more.

**❓ What if a city is not found?**
The scraper will try multiple URL patterns and search through the global directory. If not found, it returns an error record.

**❓ How do I get data for multiple cities?**
Run the actor multiple times with different `searchLocation` inputs, or use Apify's scheduler to automate batch runs.

### 🔌 Integrate with any app

- Google Sheets via Make
- Airtable via Zapier
- PostgreSQL via API
- Slack notifications
- Excel via CSV export
- Custom dashboards via JSON/XML

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Hostelworld Scraper](https://apify.com/parseforge/hostelworld-scraper) | Scrape hostels from Hostelworld |
| [Booking.com Scraper](https://apify.com/apify/booking-scraper) | Hotel and accommodation data |
| [OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more travel data actors.

***

**Disclaimer:** This actor scrapes publicly available data from Hostelz.com for informational purposes. Use responsibly and in accordance with Hostelz.com's terms of service. ParseForge is not affiliated with Hostelz.com.

# Actor input Schema

## `searchLocation` (type: `string`):

City or country to search for hostels (e.g. Barcelona, Madrid, Thailand).

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

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

## Actor input object example

```json
{
  "searchLocation": "Barcelona",
  "maxItems": 10
}
```

# 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 = {
    "searchLocation": "Barcelona",
    "maxItems": 10
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hostelz Scraper | Hostel Listings and Prices",
        "description": "Scrape hostel data from Hostelz including names, prices, ratings, locations, amenities, room types, reviews and availability. Build accommodation datasets for travel comparison, budget trip planning and hospitality market research projects at scale across the full catalog",
        "version": "0.1",
        "x-build-id": "kdNOqlSkEhkeVQIK0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~hostelz-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-hostelz-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~hostelz-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-hostelz-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~hostelz-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-hostelz-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchLocation"
                ],
                "properties": {
                    "searchLocation": {
                        "title": "Search Location",
                        "type": "string",
                        "description": "City or country to search for hostels (e.g. Barcelona, Madrid, Thailand)."
                    },
                    "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."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```