# Booking.com Hotels Scraper (`automation-lab/booking-com-hotels-scraper`) Actor

Extract Booking.com hotels by destination or direct property URL. Get prices, availability, ratings, reviews, photos, room types, filters, and structured exports.

- **URL**: https://apify.com/automation-lab/booking-com-hotels-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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Booking.com Hotels Scraper

### What does Booking.com Hotels Scraper do?

**Booking.com Hotels Scraper** extracts hotel and accommodation data from [Booking.com](https://www.booking.com) search results. Enter a city or region, set your travel dates and guest count, and get structured data on **prices, ratings, reviews, room types, and availability** -- exported as JSON, CSV, or Excel. No Booking.com account required.

> **Migration note:** This replacement uses `https://apify.com/automation-lab/booking-com-hotels-scraper`. Users, reviews, subscriptions, run history, and integrations from the old Actor URL do not migrate automatically. Update saved API, Task, schedule, webhook, and MCP references to the new Actor URL.

It uses a real browser (Playwright) to load search results, which means it handles Booking.com's AWS WAF anti-bot protection reliably. Pagination is handled automatically -- the scraper follows result pages until your `maxResults` limit is reached or all results are collected.

### Who is it for?

**Booking.com Hotels Scraper** is built for data professionals, travel industry analysts, and developers who need reliable access to Booking.com hotel data at scale — without a Booking.com API key or Affiliate Program approval.

- **Revenue managers and hoteliers** monitoring competitor pricing across their market
- **Travel agencies and OTAs** building data feeds or price comparison tools
- **Data analysts and researchers** studying hotel supply, pricing trends, and review distributions
- **Developers** integrating accommodation data into applications, dashboards, or automated pipelines
- **Individual travelers** who want to track prices for a specific destination over time

If you need hotel listing data (prices, ratings, availability) from Booking.com at any scale, this scraper handles the anti-bot complexity so you can focus on the data.

### Use cases

- **Travel price monitoring** -- track hotel prices in a destination over time to find the best booking window
- **Competitor analysis for hoteliers** -- compare your property's pricing and review scores against nearby competitors
- **Market research** -- analyze hotel supply, pricing tiers, and review distributions across cities or regions
- **Lead generation for travel agencies** -- build lists of hotels with contact pages, locations, and ratings
- **Aggregator data feeds** -- power a travel comparison site or internal dashboard with fresh Booking.com data

### Build travel content workflows with structured accommodation data

Use Booking.com Hotels Scraper to generate hotel and accommodation datasets for programmatic destination pages, affiliate travel sites, price-comparison tools, or AI-assisted CMS workflows. Search by city or region and export prices, ratings, review counts, room types, photos, availability, and Booking.com URLs as a hotel/accommodation data feed for your CMS, database, or travel data pipeline.

After collecting hotel URLs, enrich destination content and comparison pages with guest scores, positive/negative comments, stay dates, room types, traveller types, and language-filtered review text using [Booking.com Reviews Scraper](https://apify.com/automation-lab/booking-reviews-scraper).

### Why use Booking.com Hotels Scraper?

- **Handles anti-bot protection** -- uses Playwright with residential proxies to bypass Booking.com's AWS WAF, where simple HTTP scrapers fail
- **20+ data fields per hotel** -- prices, review scores, star ratings, room types, cancellation policy, breakfast, photos, and more
- **Automatic pagination** -- scrapes across multiple result pages without manual intervention
- **Flexible search filters** -- set dates, guests, rooms, price range, star rating, sort order, currency, and language
- **Pay per result** -- no monthly subscription, you only pay for the hotel results you actually scrape
- **Clean, flat output** -- every field is a primitive type (string, number, boolean), ready for spreadsheets and databases

### What data can you extract from Booking.com?

Each hotel result includes up to **21 structured fields**:

| Field | Type | Description |
|-------|------|-------------|
| name | string | Hotel or property name |
| url | string | Direct Booking.com URL (tracking params removed) |
| hotelId | number | Booking.com internal hotel ID |
| location | string | Neighborhood and city |
| starRating | number | Star rating (1-5) |
| reviewScore | number | Guest review score (0-10) |
| reviewCount | number | Total number of guest reviews |
| reviewScoreWord | string | Rating label (e.g., "Excellent", "Very Good") |
| totalResults | number | Total number of matching search results displayed by Booking.com |
| price | number | Total price for the stay |
| pricePerNight | number | Price per night |
| currency | string | Currency code (USD, EUR, GBP, etc.) |
| roomType | string | Recommended room/unit type |
| freeCancellation | boolean | Whether free cancellation is available |
| breakfastIncluded | boolean | Whether breakfast is included |
| photoUrl | string | Hotel photo URL |
| propertyType | string | Property type (Hotel, Apartment, etc.) |
| checkin | string | Check-in date (YYYY-MM-DD) |
| checkout | string | Check-out date (YYYY-MM-DD) |
| distanceFromCenter | string | Distance from city center |
| scrapedAt | string | ISO 8601 timestamp of when the data was collected |

### How much does it cost to scrape Booking.com?

This Actor uses **pay-per-event** pricing -- you pay only for what you scrape. No monthly subscription. All platform costs (compute, proxy, storage) are **included**.

Prices vary by your Apify plan (FREE, BRONZE, SILVER, GOLD, PLATINUM, DIAMOND):

| Event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
|-------|------|--------|--------|------|----------|---------|
| **Actor start** (per run) | $0.0325 | $0.0325 | $0.0325 | $0.0325 | $0.0325 | $0.0325 |
| **Per hotel scraped** | $0.00333 | $0.00290 | $0.00226 | $0.00174 | $0.00116 | $0.00081 |

**Real-world cost examples (BRONZE plan):**

| Search | Results | Estimated cost |
|--------|---------|----------------|
| London, 10 hotels | 10 | ~$0.06 |
| Paris, 30 hotels | 30 | ~$0.12 |
| New York, 75 hotels | 75 | ~$0.25 |
| Tokyo, 100 hotels | 100 | ~$0.32 |

Cost includes all platform compute, residential proxy, and storage.

> **Note:** Runs using direct hotel URLs (`startUrls`) with fewer than 5 URLs incur an additional warmup surcharge to cover browser initialization costs. For best value, batch 5+ hotels per run or use the location search mode.

### How to scrape Booking.com hotels

#### Option A: Search by location (most common)

1. Go to the [Booking.com Hotels Scraper](https://console.apify.com/actors/) input page on Apify Console
2. Enter a **Location** -- any city, region, or country (e.g., "London", "Paris, France", "Tokyo")
3. Optionally set **Check-in** and **Check-out** dates (defaults to tomorrow + 2 nights)
4. Adjust **Adults**, **Rooms**, and **Children** if needed
5. Set **Max results** to control how many hotels to scrape
6. Click **Start** and wait for results

**Example input (location search):**

```json
{
    "locationQuery": "London",
    "checkin": "2026-04-01",
    "checkout": "2026-04-03",
    "adults": 2,
    "rooms": 1,
    "maxResults": 50,
    "sortBy": "popularity",
    "currency": "USD"
}
```

#### Option B: Scrape specific hotels by direct URL

If you want data for one or more specific properties rather than a general search, paste their Booking.com URLs directly into the **Direct hotel URLs** field. The scraper visits each property page and extracts all available data. Check-in/out dates and guest counts still apply for pricing.

**Example input (direct URLs):**

```json
{
    "startUrls": [
        { "url": "https://www.booking.com/hotel/gb/the-savoy.html" },
        { "url": "https://www.booking.com/hotel/gb/claridges.html" }
    ],
    "checkin": "2026-04-01",
    "checkout": "2026-04-03",
    "adults": 2
}
```

**How to find a hotel's URL:** Search for the hotel on [booking.com](https://www.booking.com), click through to the hotel page, and copy the URL from your browser's address bar. The URL should start with `https://www.booking.com/hotel/`.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| startUrls | array | -- | Direct Booking.com hotel page URLs to scrape (e.g., `https://www.booking.com/hotel/gb/the-savoy.html`). Use this to target specific properties. Either `startUrls` or `locationQuery` is required. |
| locationQuery | string | -- | City, region, or country to search (e.g., "London", "Paris, France"). Required if no `startUrls` provided. |
| checkin | string | tomorrow | Check-in date in YYYY-MM-DD format |
| checkout | string | checkin + 2 days | Check-out date in YYYY-MM-DD format |
| adults | integer | 2 | Number of adult guests (1-30) |
| rooms | integer | 1 | Number of rooms (1-30) |
| children | integer | 0 | Number of children (0-10) |
| maxResults | integer | 100 | Maximum number of hotels to return (applies to location search only). 0 = unlimited |
| sortBy | enum | popularity | Sort order: popularity, price, bayesian\_review\_score, class, distance |
| currency | string | USD | Currency code for prices (USD, EUR, GBP, etc.) |
| language | string | en-us | Language code for results (en-us, de, fr, es, it, ja, zh-cn, etc.) |
| minPrice | integer | -- | Minimum price per night filter |
| maxPrice | integer | -- | Maximum price per night filter |
| starsFilter | string\[] | -- | Filter by star rating (e.g., \["4", "5"] for 4- and 5-star hotels only) |

### Output example

```json
{
    "name": "citizenM London Shoreditch",
    "url": "https://www.booking.com/hotel/gb/citizenm-london-shoreditch.html",
    "hotelId": 189710206,
    "location": "Hackney, London",
    "starRating": null,
    "reviewScore": 8.7,
    "reviewCount": 3356,
    "reviewScoreWord": "Excellent",
    "totalResults": 193,
    "price": 224,
    "pricePerNight": 112,
    "currency": "USD",
    "roomType": null,
    "freeCancellation": false,
    "breakfastIncluded": false,
    "photoUrl": "https://cf.bstatic.com/xdata/images/hotel/square240/772469398.webp?k=...",
    "propertyType": null,
    "checkin": "2026-04-01",
    "checkout": "2026-04-03",
    "distanceFromCenter": "2.4 miles from downtown",
    "scrapedAt": "2026-03-05T00:40:43.148Z"
}
```

### Tips for best results

- **Target specific hotels with direct URLs** -- if you want data for specific properties, use `startUrls` with their Booking.com hotel URLs instead of searching by location. This is more reliable than hotel-name searches.
- **Start small** -- test with `maxResults: 10` before running large scrapes to verify your search returns what you expect
- **Set specific dates** -- Booking.com prices vary significantly by date; always set `checkin` and `checkout` for accurate pricing
- **Use price filters** -- narrow results with `minPrice` and `maxPrice` to focus on your target segment
- **Filter by stars** -- use `starsFilter: ["4", "5"]` to only get upscale properties
- **Sort by price** -- set `sortBy: "price"` to get the cheapest options first, useful for budget monitoring
- **Change currency** -- set `currency` to your local currency to avoid conversion math
- **Pagination is automatic** -- the scraper loads additional result pages as needed until `maxResults` is reached
- **Residential proxies recommended** -- the actor uses residential proxies by default for best reliability against Booking.com's WAF

### Integrations

Connect Booking.com Hotels Scraper to other apps and services using Apify integrations:

- **Google Sheets** -- automatically export hotel data to a spreadsheet for tracking prices over time
- **Slack / Discord** -- get notified when a scraping run finishes
- **Zapier / Make** -- trigger workflows when new hotel data is available (e.g., alert when prices drop)
- **Webhooks** -- send results directly to your own API endpoint
- **Schedule** -- run the scraper automatically on a daily or weekly basis to monitor price changes

See [Apify integrations](https://apify.com/integrations) for the full list.

### API usage

You can run Booking.com Hotels Scraper programmatically using the Apify API. This is useful for integrating hotel data into your own applications or automated pipelines.

**cURL:**

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~booking-com-hotels-scraper/runs?token=YOUR_API_TOKEN&waitForFinish=300" \
  -H "Content-Type: application/json" \
  -d '{
    "locationQuery": "London",
    "checkin": "2026-04-01",
    "checkout": "2026-04-03",
    "adults": 2,
    "rooms": 1,
    "maxResults": 50,
    "currency": "USD"
  }'
```

**Node.js:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/booking-com-hotels-scraper').call({
    locationQuery: 'London',
    checkin: '2026-04-01',
    checkout: '2026-04-03',
    adults: 2,
    rooms: 1,
    maxResults: 50,
    currency: 'USD',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Found ${items.length} hotels`);
console.log(items[0]);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/booking-com-hotels-scraper').call(run_input={
    'locationQuery': 'London',
    'checkin': '2026-04-01',
    'checkout': '2026-04-03',
    'adults': 2,
    'rooms': 1,
    'maxResults': 50,
    'currency': 'USD',
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(f'Found {len(items)} hotels')
print(items[0])
```

### Use with AI agents via MCP

[Booking.com Hotels Scraper](https://apify.com/automation-lab/booking-com-hotels-scraper) is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

#### Setup for Claude Code

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

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

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

#### Example prompts

Once connected, try asking your AI assistant:

- "Find hotels in Paris for June 15-20 under $150/night"
- "Scrape hotel prices and ratings in downtown Barcelona"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### FAQ

**How does this scraper handle Booking.com's anti-bot protection?**
Booking.com uses AWS WAF to block automated requests. This scraper uses a full Playwright browser with residential proxies and anti-detection flags, which bypasses the WAF reliably. Simple HTTP-based scrapers typically get blocked.

**Can I scrape hotels in any country?**
Yes. Enter any city, region, or country name in the `locationQuery` field. Booking.com covers over 2.5 million properties worldwide. You can also set the `language` parameter to get results in your preferred language.

**How many hotels can I scrape in one run?**
There is no hard limit. Set `maxResults: 0` for unlimited. The scraper automatically paginates through all available results. A typical city search returns 200-1,000+ properties depending on the destination.

**Does it scrape individual hotel detail pages?**
Yes — use the `startUrls` input to provide direct Booking.com hotel URLs (e.g., `https://www.booking.com/hotel/gb/the-savoy.html`). The scraper visits each page and extracts the hotel's name, rating, reviews, location, photos, and availability pricing. This is the recommended approach when you want data for specific properties rather than a general city search.

**How do I scrape a specific hotel by name?**
The most reliable approach is to use `startUrls` with the hotel's direct Booking.com URL. Find the URL by searching on booking.com, clicking the hotel, and copying the address bar URL. Alternatively, you can enter a hotel name in `locationQuery` and the scraper will use Booking.com's autocomplete to resolve it — however, autocomplete may return nearby landmarks or areas instead of the exact property, so results may include nearby hotels rather than just the one you searched for.

**Can I filter results by price range or star rating?**
Yes. Use `minPrice` and `maxPrice` to set a nightly price range, and `starsFilter` to limit results to specific star ratings (e.g., `["4", "5"]` for 4- and 5-star hotels).

**What happens if Booking.com shows a CAPTCHA?**
The scraper detects WAF challenge pages and automatically retries with a different proxy. If challenges persist, it will retry up to 3 times per page before moving on.

**Can I export results to CSV or Excel?**
Yes. Apify datasets support JSON, CSV, Excel, XML, and HTML export formats. Use the dataset export buttons in Apify Console or the API.

**How fast is the scraper?**
Speed depends on the number of results and pagination depth. A typical 50-hotel scrape completes in 30-60 seconds. The scraper uses browser rendering, so it is slower than HTTP-based scrapers but handles anti-bot measures that HTTP scrapers cannot.

**The scraper is returning 0 results. What should I check?**
Verify your `locationQuery` is a valid Booking.com destination. Try using the same search on booking.com first to confirm results exist. If dates are in the past or availability is limited, you may get fewer results. Also check the run log for WAF challenge messages -- occasional retries are normal, but persistent blocks may require switching proxy groups.

**Why are some fields null (starRating, roomType, propertyType)?**
Booking.com doesn't show all fields for every property in search results. Non-rated properties (hostels, apartments) may lack star ratings. Room type may not be displayed if multiple room options are available. These fields are extracted as-is from the search results page.

**Can I monitor prices over time?**
Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run the scraper daily or weekly with the same search parameters. Export to [Google Sheets](https://apify.com/integrations/google-sheets) to build a price tracking spreadsheet, or use webhooks to trigger alerts when prices drop below a threshold.

### Legality

Booking.com Hotels Scraper only accesses publicly available hotel listing data from Booking.com search results. It does not bypass any login walls, CAPTCHAs, or access controls. The data collected is the same as what any visitor can see when searching for hotels on booking.com without an account.

Web scraping of publicly available data is generally legal, but you should review Booking.com's Terms of Service and applicable laws in your jurisdiction. Use the data responsibly and in compliance with privacy regulations like GDPR. You can read more about the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### How do I monitor Booking.com hotel prices over time?

Use Apify's built-in scheduling to run the scraper automatically on a recurring basis with the same search parameters:

1. Save your search input (location, dates, filters)
2. Go to **Schedules** in Apify Console and set up a daily or weekly run
3. Export each run to Google Sheets using the [Google Sheets integration](https://apify.com/integrations/google-sheets) to build a price history spreadsheet
4. Use webhooks or Zapier to trigger alerts when prices drop below a threshold

This approach is widely used by travel agencies, hotel revenue managers, and deal hunters who want to book at the optimal time.

### Can I scrape hotel reviews from Booking.com?

This scraper extracts review **scores and counts** from search result pages — you get `reviewScore` (0–10), `reviewCount`, and `reviewScoreWord` (e.g., "Excellent") for each hotel. However, it does not scrape individual review text, since reviews live on individual hotel pages rather than search results.

If you need full review text for specific hotels, you would need to follow individual hotel URLs — a feature that may be added in a future version.

### Does Booking.com block scrapers?

Yes. Booking.com uses AWS WAF (Web Application Firewall) to detect and block automated traffic. Standard HTTP scrapers are typically blocked immediately. This actor bypasses the WAF by:

- Using a full Playwright browser (same as a real user's browser)
- Routing requests through residential proxy IPs (not datacenter IPs)
- Applying browser fingerprint randomization and anti-detection flags

This approach reliably handles Booking.com's WAF challenges. If you encounter persistent blocks, the scraper automatically retries with different proxy IPs up to 3 times per page.

### What are the best alternatives to the Booking.com API?

Booking.com does not offer a public API for accommodation search data. There are two main options for programmatic access:

- **Affiliate API** — Booking.com's [Affiliate Partner Program](https://www.booking.com/affiliate-program/) provides a search API, but requires approval and revenue sharing. It's intended for travel booking integrations, not data analysis.
- **Web scraping** — The most flexible option for data analysis, price monitoring, and market research. This scraper handles all the anti-bot complexity for you and exports clean structured data.

For market research, price tracking, and competitive analysis, scraping is typically the faster path since the affiliate API requires partnership approval.

### Related scrapers

- [Ryanair Flight Price Scraper](https://apify.com/automation-lab/ryanair-flight-price-scraper) — Track Ryanair fare-calendar prices for trip cost monitoring, price-drop alerts, and n8n or Google Sheets automation
- [Google Flights Scraper](https://apify.com/automation-lab/google-flights-scraper) — Extract flight search prices and schedules for broader airfare comparisons
- [Airbnb Scraper](https://apify.com/automation-lab/airbnb-listing) — Scrape Airbnb listings, prices, and availability
- [Airbnb Reviews Scraper](https://apify.com/automation-lab/airbnb-reviews) — Extract guest reviews from Airbnb listings

# Actor input Schema

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

List of direct Booking.com hotel page URLs to scrape (e.g., https://www.booking.com/hotel/gb/the-savoy.html). If provided, the scraper visits each URL directly instead of running a location search. Check-in/check-out dates and guest counts still apply for pricing.

## `locationQuery` (type: `string`):

City, region, country, or hotel name to search (e.g., 'London', 'Paris, France', 'The Savoy London'). Hotel names are resolved via Booking.com autocomplete and return results for that specific property. Required if no Start URLs are provided.

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

Deprecated backwards-compatible alias for locationQuery. Existing integrations may continue sending search.

## `checkin` (type: `string`):

Check-in date in YYYY-MM-DD format. Defaults to tomorrow if not specified.

## `checkout` (type: `string`):

Check-out date in YYYY-MM-DD format. Defaults to 2 days after check-in if not specified.

## `adults` (type: `integer`):

Number of adult guests.

## `rooms` (type: `integer`):

Number of rooms.

## `children` (type: `integer`):

Number of children.

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

Maximum number of hotels to return. Set to 0 for unlimited.

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

Deprecated backwards-compatible alias for maxResults. Existing integrations may continue sending maxItems.

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

Sort order for search results.

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

Currency code for prices (e.g., USD, EUR, GBP).

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

Language for results (e.g., en-us, de, fr, es, it, pt-br, ja, zh-cn).

## `minPrice` (type: `integer`):

Minimum price per night filter.

## `maxPrice` (type: `integer`):

Maximum price per night filter.

## `starsFilter` (type: `array`):

Filter by hotel star rating. Enter star values (1-5) to include.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.booking.com/hotel/gb/the-savoy.html"
    }
  ],
  "locationQuery": "London",
  "checkin": "2026-06-01",
  "checkout": "2026-06-03",
  "adults": 2,
  "rooms": 1,
  "children": 0,
  "maxResults": 10,
  "sortBy": "popularity",
  "currency": "USD",
  "language": "en-us",
  "minPrice": 100,
  "maxPrice": 300,
  "starsFilter": [
    "4",
    "5"
  ]
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset in the hotel overview table view.

# 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.booking.com/hotel/gb/the-savoy.html"
        }
    ],
    "locationQuery": "London",
    "maxResults": 10,
    "minPrice": 100,
    "starsFilter": [
        "4",
        "5"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/booking-com-hotels-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.booking.com/hotel/gb/the-savoy.html" }],
    "locationQuery": "London",
    "maxResults": 10,
    "minPrice": 100,
    "starsFilter": [
        "4",
        "5",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/booking-com-hotels-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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.booking.com/hotel/gb/the-savoy.html"
    }
  ],
  "locationQuery": "London",
  "maxResults": 10,
  "minPrice": 100,
  "starsFilter": [
    "4",
    "5"
  ]
}' |
apify call automation-lab/booking-com-hotels-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/booking-com-hotels-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/hJHdjPcGZbyxi4H5S/builds/5Av6dHycBUEbo4JMK/openapi.json