# Booking.com Hotel Price & Amenity Search Scraper (`nimbryxo-studio/booking-com-hotel-price-and-amenity-search-scraper`) Actor

Search Booking.com for a destination and dates, and collect each property's price, rating, review count, amenities, and breakfast info for the stay you specify.

- **URL**: https://apify.com/nimbryxo-studio/booking-com-hotel-price-and-amenity-search-scraper.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Travel, Automation, E-commerce
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 69.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Booking.com Hotel Search & Details Scraper

Search Booking.com for a destination and travel dates, or paste hotel links directly, and get one row per property with the stay price, room and rate options, guest scores, review subscores, facilities, photos, description and booking policies.

### What this actor does

- **Search mode** runs a Booking.com destination search for your dates, guests and filters, then scrolls and clicks **Load more results** to go beyond the first page. It collects up to 250 properties per run.
- **Details mode** loads Booking.com hotel URLs you provide and returns the same rich row for each one.
- Solves Booking.com's AWS WAF challenge once in a browser, then reuses the session cookie over HTTP for the rest of the run. If a detail request is challenged again, the actor refreshes the cookie and falls back to the browser for that page.
- Applies Booking.com's own filters for property type, review score, stars, free cancellation, breakfast, pool and nightly price.
- Returns the cheapest room-table price for the whole stay, plus every room and rate option when `includeRooms` is on.
- Optionally renders each hotel in a browser to collect the complete facility list, not just the headline amenities.
- If some detail pages fail, the run finishes with a `PARTIAL` warning and keeps the search rows instead of failing the whole run.

### Output per hotel

| Field | What it contains |
|---|---|
| `hotelId`, `name`, `url` | Property identity and its Booking.com page |
| `propertyType`, `stars` | Property type and star rating |
| `address`, `city`, `country` | Full address and location |
| `latitude`, `longitude` | Map coordinates |
| `distance` | Distance from the city centre as Booking.com shows it |
| `rating`, `reviewCount`, `reviewWord` | Guest score, number of reviews and Booking.com's label |
| `reviewSubscores` | Category scores such as Location, Cleanliness and Staff |
| `price`, `pricePerNight`, `currency` | Cheapest total for the stay, nightly equivalent and ISO currency code |
| `originalPrice`, `discountPercent` | Pre-discount price and discount percentage when a deal is shown |
| `taxesAndFees`, `priceWithTaxes` | Taxes and fees for the cheapest rate and the resulting total |
| `roomTypes` | Room name, rate-plan count, price, original price, total, taxes, breakfast, cancellation, sleeps, bed, size and room amenities |
| `topAmenities`, `fullAmenities` | Headline facilities, plus the complete list when `includeFullAmenities` is on |
| `amenities` | Amenity keywords found on the search card |
| `photos`, `photoUrl` | Photo URLs and the main image |
| `description` | Property description |
| `breakfastIncluded`, `breakfastAvailable`, `breakfastPrice` | Whether breakfast is included, merely available, or paid separately |
| `freeCancellation` | Whether a free-cancellation rate exists |
| `checkinTime`, `checkoutTime` | Property check-in and check-out times |
| `checkin`, `checkout`, `nights`, `adults`, `rooms` | The stay used for pricing |
| `mode`, `detailStatus`, `source`, `scrapedAt` | Run metadata and enrichment status |

Empty values are omitted from a record instead of being written as `null`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `search` | `search` a destination or load hotel `details` |
| `destination` | string | – | City, region or landmark; required in search mode |
| `startUrls` | array | `[]` | Booking.com hotel URLs; required in details mode |
| `checkIn` | string | - | Check-in date (`YYYY-MM-DD`); empty uses tomorrow |
| `checkOut` | string | - | Check-out date (`YYYY-MM-DD`); empty uses a 3-night stay |
| `adults` | integer | `2` | Adult guests (1–30) |
| `rooms` | integer | `1` | Rooms needed (1–30) |
| `propertyType` | select | `all` | All, hotels, apartments, hostels, guesthouses, villas or resorts |
| `minReviewScore` | number | `0` | Minimum guest score (0–10) |
| `stars` | select | `0` | Exact star rating, or any |
| `freeCancellation` | boolean | `false` | Keep properties with a free-cancellation rate |
| `breakfast` | boolean | `false` | Keep properties with breakfast included |
| `pool` | boolean | `false` | Keep properties with a swimming pool |
| `minPrice`, `maxPrice` | number | – | Nightly price bounds in the chosen currency |
| `currency` | string | `USD` | Three-letter currency code |
| `language` | select | `en-us` | Page language |
| `maxItems` | integer | `3` | Maximum hotels to return (1–250) |
| `includeRooms` | boolean | `true` | Add the room and rate table |
| `includeFullAmenities` | boolean | `false` | Render each hotel page to collect every facility |
| `proxyConfiguration` | object | AUTO | Apify proxy used for browser and HTTP requests |

#### Example: search Paris for three nights

```json
{
  "mode": "search",
  "destination": "Paris",
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-13",
  "adults": 2,
  "rooms": 1,
  "maxItems": 3,
  "includeFullAmenities": false
}
```

#### Example: five-star hotels with a pool and free cancellation

```json
{
  "mode": "search",
  "destination": "Barcelona",
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-13",
  "stars": 5,
  "pool": true,
  "freeCancellation": true,
  "minReviewScore": 8,
  "currency": "EUR",
  "maxItems": 25
}
```

#### Example: load specific hotel pages

```json
{
  "mode": "details",
  "startUrls": [
    { "url": "https://www.booking.com/hotel/fr/sorbonne.html" },
    { "url": "https://www.booking.com/hotel/fr/moxy-paris-la-villette.html" }
  ],
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-13",
  "includeRooms": true,
  "includeFullAmenities": true
}
```

### Use cases

- **Price comparison** — compare stay totals for the same dates across a destination
- **Rate tracking** — schedule runs to watch prices and discounts move
- **Room-level analysis** — compare room types, breakfast and cancellation terms
- **Travel apps and spreadsheets** — feed structured hotel data into your own tools
- **Market research** — analyse ratings, review subscores and facilities by city or property type

### FAQ

**Do I need a Booking.com account?**
No. The actor reads public hotel and search pages. It solves the site's technical challenge without you providing cookies or a login.

**Why does the first request take longer?**
Booking.com uses an AWS WAF JavaScript challenge. The actor opens one browser page to solve it, then reuses the resulting cookie over HTTP. That bootstrap is a few seconds per run.

**What does `price` mean?**
It is the cheapest total for the whole stay, for the dates, guest count and room count in your input. `pricePerNight` divides that total by the number of nights. Use `originalPrice` when Booking.com shows a strike-through price.

**Why do some prices differ from the search card?**
The search card can show a promotional or selected-room price. The detail parser takes the cheapest valid room-table price, which is the same number Booking.com uses for the cheapest rate on that page.

**Why is `fullAmenities` missing?**
It is only collected when `includeFullAmenities` is on. That setting renders a hotel page in a browser, so it is slower and costs more than the default HTTP-only detail fetch.

**What happens when Booking.com blocks the run?**
The actor fails with a `BLOCKED` status instead of returning an empty dataset. If only some detail pages fail, it finishes with a `PARTIAL` status and keeps the rows it did collect.

**What happens when a search has no results?**
A valid search with no matches fails with `NO_RESULTS`, so you can tell it apart from a block. Loosen your filters or check the destination spelling.

**How many results can I get?**
Set `maxItems` up to 250. Booking.com loads 25 cards at a time and exposes a "Load more results" button; the actor scrolls and clicks it until your cap or the page stops growing. Booking.com itself caps a single query at about 1,000 results.

**Are prices and availability live?**
Yes. They are captured when the actor runs and can change as availability changes.

**Is this affiliated with Booking.com?**
No. This is an independent third-party actor that reads publicly available Booking.com pages.

# Actor input Schema

## `mode` (type: `string`):

Search a destination, or load specific Booking.com hotel URLs.

## `destination` (type: `string`):

City, region or landmark to search, e.g. Paris, New York or Tokyo. Required in search mode.

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

Booking.com hotel page URLs, used in details mode. Copy links from a search result or your browser.

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

Check-in date as YYYY-MM-DD. Leave empty to use tomorrow.

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

Check-out date as YYYY-MM-DD. Leave empty to use a 3-night stay.

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

Number of adult guests.

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

Number of rooms needed.

## `propertyType` (type: `string`):

Keep only one Booking.com property type, or search all types.

## `minReviewScore` (type: `number`):

Minimum guest score from 0 to 10. The actor applies Booking.com's score filter and then keeps only properties at or above this exact score.

## `stars` (type: `string`):

Keep only properties with this star rating, or any star rating.

## `freeCancellation` (type: `boolean`):

Return properties with at least one free-cancellation rate.

## `breakfast` (type: `boolean`):

Return properties with a breakfast-included rate.

## `pool` (type: `boolean`):

Return properties that have a swimming pool.

## `minPrice` (type: `number`):

Optional lower bound for the nightly price in the chosen currency.

## `maxPrice` (type: `number`):

Optional upper bound for the nightly price in the chosen currency.

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

Three-letter currency code such as USD, EUR or GBP.

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

Language Booking.com should use for the pages.

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

Stop after this many hotels.

## `includeRooms` (type: `boolean`):

Add the room and rate table for each hotel. Turn off for a smaller, faster dataset.

## `includeFullAmenities` (type: `boolean`):

Render each hotel page in a browser to collect the complete facility list. Slower and only needed when you want every amenity.

## `proxyConfiguration` (type: `object`):

Booking.com uses an AWS WAF challenge. Apify's AUTO proxy is prefilled; the actor uses this proxy for browser and HTTP requests.

## Actor input object example

```json
{
  "mode": "search",
  "destination": "Paris",
  "startUrls": [
    {
      "url": "https://www.booking.com/hotel/fr/du-printemps-paris.html"
    }
  ],
  "adults": 2,
  "rooms": 1,
  "propertyType": "all",
  "minReviewScore": 0,
  "stars": "0",
  "freeCancellation": false,
  "breakfast": false,
  "pool": false,
  "currency": "USD",
  "language": "en-us",
  "maxItems": 1,
  "includeRooms": false,
  "includeFullAmenities": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `hotels` (type: `string`):

Dataset containing every scraped Booking.com property.

# 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 = {
    "mode": "search",
    "destination": "Paris",
    "startUrls": [
        {
            "url": "https://www.booking.com/hotel/fr/du-printemps-paris.html"
        }
    ],
    "adults": 2,
    "rooms": 1,
    "propertyType": "all",
    "stars": "0",
    "freeCancellation": false,
    "breakfast": false,
    "pool": false,
    "currency": "USD",
    "language": "en-us",
    "maxItems": 1,
    "includeRooms": false,
    "includeFullAmenities": false,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/booking-com-hotel-price-and-amenity-search-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 = {
    "mode": "search",
    "destination": "Paris",
    "startUrls": [{ "url": "https://www.booking.com/hotel/fr/du-printemps-paris.html" }],
    "adults": 2,
    "rooms": 1,
    "propertyType": "all",
    "stars": "0",
    "freeCancellation": False,
    "breakfast": False,
    "pool": False,
    "currency": "USD",
    "language": "en-us",
    "maxItems": 1,
    "includeRooms": False,
    "includeFullAmenities": False,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/booking-com-hotel-price-and-amenity-search-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 '{
  "mode": "search",
  "destination": "Paris",
  "startUrls": [
    {
      "url": "https://www.booking.com/hotel/fr/du-printemps-paris.html"
    }
  ],
  "adults": 2,
  "rooms": 1,
  "propertyType": "all",
  "stars": "0",
  "freeCancellation": false,
  "breakfast": false,
  "pool": false,
  "currency": "USD",
  "language": "en-us",
  "maxItems": 1,
  "includeRooms": false,
  "includeFullAmenities": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nimbryxo-studio/booking-com-hotel-price-and-amenity-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/booking-com-hotel-price-and-amenity-search-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/sWIaAOuau5dEgTrPA/builds/cTXCXZCoq14RlU0gU/openapi.json