# Booking.com Scraper — Hotel Prices, Ratings & Availability (`studio-amba/booking-scraper`) Actor

Scrape live hotel search results from Booking.com: name, address, review score, review count, price per night and total, currency, and direct booking links for any European destination and dates.

- **URL**: https://apify.com/studio-amba/booking-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### What does Booking.com Scraper do?

**Booking.com Scraper** extracts live hotel search results from
[Booking.com](https://www.booking.com), Europe's largest online travel
agency. Give it a destination and check-in/check-out dates, and it returns
the hotels Booking.com's own destination search surfaces for those dates:
name, address, guest review score, review count, price per night and total,
currency, and a direct booking link. No login or cookies required.

Use it to collect structured hotel data via the Apify platform with full
**API access, scheduling, integrations**, and no need to run a browser
yourself.

### Why use Booking.com Scraper?

- **Price monitoring** — Track nightly rates for specific hotels or
  destinations over time and catch price drops or spikes
- **Travel research** — Compare guest review scores, prices, and locations
  for a destination without manually clicking through the site
- **Rate benchmarking** — Feed live Booking.com pricing into your own
  competitor or market-rate analysis
- **Meta-search / travel apps** — Pull current Booking.com listings into
  your own booking tool or comparison site
- **Corporate travel** — Check hotel rates for upcoming business trips in
  bulk, across multiple destinations and date ranges

### How to use Booking.com Scraper

1. Go to the **Input** tab
2. Enter a **Destination** (city, region, or landmark, e.g. `Amsterdam`, `Paris`, `Rijksmuseum`)
3. Enter a **Check-in date** and **Check-out date** in `YYYY-MM-DD` format
4. Optionally set adults, rooms, max results, or a review-score/price filter
5. Click **Start** and wait for the run to finish
6. Download your data from the **Output** tab in JSON, CSV, Excel, or other formats

### Input

| Field | Type | Required | Description |
|-------|------|----------|--------------|
| `destination` | String | No | City, region, or landmark (default: `Amsterdam`) |
| `checkIn` | String | No | Check-in date, `YYYY-MM-DD` (default: ~30 days out) |
| `checkOut` | String | No | Check-out date, `YYYY-MM-DD` (default: check-in + 2 nights) |
| `adults` | Integer | No | Number of adult guests (default: 2) |
| `rooms` | Integer | No | Number of rooms (default: 1) |
| `maxResults` | Integer | No | Maximum hotels to return, up to 30 (default: 20) |
| `minReviewScore` | Number | No | Post-filter: minimum guest review score (0-10 scale) |
| `minPricePerNight` | Integer | No | Post-filter: minimum price per night |
| `maxPricePerNight` | Integer | No | Post-filter: maximum price per night |
| `proxyConfiguration` | Object | No | Proxy settings (Apify automatic proxy works — see Limitations) |

The three filter fields are applied to Booking.com's own results **after**
they load — they don't change what Booking.com searches, only what gets
pushed to the dataset. Booking.com's own search already returns its
best-matching properties for the destination and dates, so this is a
sharpening filter, not a full re-query.

### Output

Booking.com's own destination search surfaces its top-matching hotels for
the given destination and dates — typically 6 to 20 properties, not a fully
paginated catalogue of every hotel in a city. `maxResults` caps how many of
those get pushed; it does not trigger extra requests or unlock more results.

| Field | Type | Example |
|-------|------|---------|
| `hotelName` | String | `"Tribe Amsterdam City"` |
| `address` | String | `"Hotel in Amsterdam Noord, Amsterdam"` |
| `reviewScore` | Number | `9.0` |
| `reviewScoreWord` | String | `"Wonderful"` |
| `reviewCount` | Number | `5922` |
| `priceTotal` | Number | `91.07` |
| `pricePerNight` | Number | `45.54` |
| `currency` | String | `"EUR"` |
| `nights` | Number | `2` |
| `availability` | Boolean | `true` |
| `url` | String | Direct hotel page on Booking.com |
| `imageUrl` | String | Primary hotel photo URL |

### Example output

```json
{
    "hotelId": "tribe-amsterdam-city",
    "hotelName": "Tribe Amsterdam City",
    "url": "https://www.booking.com/hotel/nl/tribe-amsterdam-city.html",
    "address": "Hotel in Amsterdam Noord, Amsterdam",
    "city": "Amsterdam",
    "countryCode": "nl",
    "starRating": null,
    "reviewScore": 9.0,
    "reviewScoreScale": "1-10",
    "reviewScoreWord": "Wonderful",
    "reviewCount": 5922,
    "priceTotal": 91.07,
    "pricePerNight": 91.07,
    "currency": "EUR",
    "nights": 1,
    "roomType": null,
    "availability": true,
    "imageUrl": "https://cf.bstatic.com/xdata/images/hotel/square600/880172813.webp",
    "checkIn": "2026-10-19",
    "checkOut": "2026-10-21",
    "adults": 2,
    "searchDestination": "Amsterdam",
    "scrapedAt": "2026-09-04T18:30:00.000Z"
}
```

### Data fields

| Field | Description | Example |
|-------|-------------|---------|
| `reviewScore` | Guest review score on Booking.com's own 1-10 scale | 9.0 |
| `reviewScoreWord` | Booking.com's own label for the score | Wonderful |
| `priceTotal` | Booking.com's own "Price from" figure, for the stay length in `nights` — see Limitations | 91.07 |
| `pricePerNight` | `priceTotal` divided by `nights` | 91.07 |
| `nights` | Stay length `priceTotal` actually covers, per Booking.com's own label — see Limitations | 1 |
| `availability` | `true` = bookable at the searched dates, `false` = explicitly sold out, `null` = not stated | true |
| `starRating` | Official star classification — see Limitations | null |
| `roomType` | Specific room/rate name — see Limitations | null |

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

Booking.com is protected by AWS WAF Bot Control and renders results
client-side, so this actor uses a real, JS-executing headless browser
rather than a plain HTTP request. The browser + compute cost is folded into
the actor's per-event price, not billed separately.

It costs $0.01 per run plus $0.005 per result (per hotel returned). A typical search
returning 10-20 hotels costs roughly $0.06-$0.11. Running the same
destination repeatedly (e.g. daily rate tracking) is the most cost-efficient
way to use this actor, since each run is one browser session covering the
whole search.

The Apify Free plan includes $5 of monthly credits. Usage cost for a run
only settles after it reports **SUCCEEDED** — reading the dataset mid-run
will undercount what the run ultimately costs.

### Limitations

- **Curated results, not a full catalogue.** Booking.com's own destination
  search returns its top-matching properties for the destination and dates
  (typically 6-20), not every hotel in a city. This actor returns exactly
  what Booking.com's search surfaces — it does not paginate beyond that.
- **`starRating` and `roomType` are usually null.** Booking.com doesn't
  expose official star classification or a specific room/rate name at the
  search-result level for most destinations — only guest review score,
  which this actor does capture reliably.
- **Price is Booking.com's own "Price from" indicator, not always scaled to
  the full requested stay.** Verified live: this destination-search price
  is tied to Booking's own reference period for the property (`nights` in
  the output, often 1 night) rather than always recalculating for the exact
  `checkIn`-`checkOut` span you searched — the same behavior you'd see
  browsing Booking.com's own destination pages directly. Use `nights`
  alongside `priceTotal`/`pricePerNight` rather than assuming it always
  matches `checkOut` minus `checkIn`.
- **Proxy.** This actor uses a Residential proxy by default. Booking.com's
  AWS WAF Bot Control silently stalls every connection from Apify's
  automatic (datacenter) proxy pool — verified live, every attempt timed
  out with no response at all. Residential clears it reliably.
- **Occupancy changes are best-effort.** Adjusting `adults`/`rooms` away
  from Booking.com's own defaults (2 adults, 1 room) uses UI automation
  that can occasionally fail silently; the search still runs with whatever
  occupancy was actually set.
- Data is scraped from the public website and may change without notice.
- Respect Booking.com's terms of service and use responsibly.

### FAQ and support

**Is it legal to scrape Booking.com?**
Booking.com Scraper accesses only publicly available hotel search results
that any visitor can see, without logging in or bypassing payment. Always
review and comply with the target website's Terms of Service before use.

**Why did I get fewer results than `maxResults`?**
Booking.com's own destination search for that city/date combination
returned fewer hotels than your `maxResults` value, or a review-score/price
filter excluded some of them. See Output above.

**I found a bug or need help**
Please submit an issue on the [Issues tab](https://console.apify.com/actors/booking-scraper/issues) and we'll get back to you quickly. For custom scraping solutions, reach out via the same channel.

### How to scrape Booking.com data

1. Go to this actor's page on the [Apify Store](https://apify.com/store).
2. Click **Try for free** to open it in Apify Console.
3. Enter your destination, check-in date, and check-out date.
4. Set the number of adults, rooms, and max results if needed.
5. Click **Start** and wait for the run to finish — most searches complete
   in under a minute.
6. Download your data in JSON, CSV, Excel, or connect it to your workflow
   via the Apify API.

You can also schedule daily runs to track hotel rates in a destination over
time, set up webhooks for price-drop notifications, or integrate results
directly into your own booking or comparison tool using the
[Apify API](https://docs.apify.com/api).

### Related Scrapers

- [Skyscanner Scraper](https://apify.com/studio-amba/skyscanner-scraper) — flight prices and search results
- [Rental Cars Scraper](https://apify.com/studio-amba/rental-cars-scraper) — car rental prices and availability
- [Sunweb Scraper](https://apify.com/studio-amba/sunweb-scraper) — package holiday deals
- [GetYourGuide Scraper](https://apify.com/studio-amba/getyourguide-scraper) — tours and activities
- [Trainline Scraper](https://apify.com/studio-amba/trainline-scraper) — train tickets and schedules

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
price-drop alerts, delta detection, and delivery to your inbox, Google
Sheets, or API — maintenance included. We can also build a custom version
with room-level detail, multi-destination batches, or your exact fields.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 700+ European web scrapers and answer within one business day.

# Actor input Schema

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

City, region, or landmark to search (e.g. 'Amsterdam', 'Paris', 'Rijksmuseum'). Matched via Booking.com's own destination autosuggest.

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

Check-in date in YYYY-MM-DD format. Must be in the future.

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

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

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

Number of adult guests. Booking.com's own default is 2.

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

Number of rooms. Booking.com's own default is 1.

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

Maximum number of hotels to return. Booking.com's own destination search surfaces its top-matching properties for the given dates (typically 6-20) rather than a fully paginated catalogue — raising this does not trigger extra requests, it only caps how many of the already-loaded results are pushed.

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

Optional post-filter: only keep hotels with a guest review score at or above this value (Booking.com's own 1-10 scale).

## `minPricePerNight` (type: `integer`):

Optional post-filter: only keep hotels priced at or above this amount per night, in the currency Booking.com displayed for the run.

## `maxPricePerNight` (type: `integer`):

Optional post-filter: only keep hotels priced at or below this amount per night, in the currency Booking.com displayed for the run.

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

Residential proxy is required. Booking.com's AWS WAF Bot Control silently stalls every connection from Apify's automatic (datacenter) proxy pool (verified live) — Residential clears it reliably.

## Actor input object example

```json
{
  "destination": "Amsterdam",
  "checkIn": "2026-10-15",
  "checkOut": "2026-10-17",
  "adults": 2,
  "rooms": 1,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "destination": "Amsterdam",
    "checkIn": "2026-10-15",
    "checkOut": "2026-10-17",
    "adults": 2,
    "rooms": 1,
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/booking-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 = {
    "destination": "Amsterdam",
    "checkIn": "2026-10-15",
    "checkOut": "2026-10-17",
    "adults": 2,
    "rooms": 1,
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/booking-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 '{
  "destination": "Amsterdam",
  "checkIn": "2026-10-15",
  "checkOut": "2026-10-17",
  "adults": 2,
  "rooms": 1,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/booking-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/booking-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/ZIGZSf97Ew5qm3g5T/builds/XSmlDSvM717w6BrXX/openapi.json