# Booking.com Scraper - Hotels, Prices & Availability (`scrapesage/booking-scraper`) Actor

Scrape Booking.com hotels with live room prices, availability, discounts, taxes, review scores, star ratings, room types, free-cancellation & breakfast flags, photos and map coordinates. Search any destination, city, landmark or hotel by name or URL. Monitor price drops. Export JSON, CSV, Excel.

- **URL**: https://apify.com/scrapesage/booking-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Travel, Lead generation, Automation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 hotel 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/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 Scraper - Hotels, Prices & Availability

Extract **complete Booking.com hotel data** for any destination — **live room prices** (with taxes & fees and the crossed-out "was" price + discount %), **real-time availability**, **guest review scores & counts**, **star ratings**, **room types** (with beds, bedrooms & bathrooms), **free-cancellation** and **breakfast-included** flags, per-offer **room lists**, **map coordinates**, the **main photo** and a **direct booking URL**. Search by destination, landmark, airport or hotel name — or paste a Booking.com URL.

No login, no cookies, no browser, no API key — fast JSON extraction straight from Booking's own data backend, with built-in **price & availability monitoring**.

### Why this Booking.com scraper?

Most Booking scrapers give you a name, a score and a price. This actor pulls the **full** record Booking renders for each property and ships the **richest dataset in the category**:

| Data | Typical scrapers | This actor |
|---|---|---|
| Hotel name, star rating, city | ✅ | ✅ |
| Live room price + currency | ✅ | ✅ |
| Total **taxes & fees** text | ❌ | ✅ |
| Crossed-out "was" price + **discount %** | ❌ | ✅ |
| **Availability** (sold-out detection) | ❌ | ✅ |
| Guest review score + **review count** + label | partial | ✅ |
| **Free cancellation** & **no prepayment** flags | ❌ | ✅ |
| **Breakfast included** flag + meal plan | ❌ | ✅ |
| Room type + beds / bedrooms / bathrooms | ❌ | ✅ |
| Per-offer **room list** (price, free-cancel deadline, meal) | ❌ | ✅ opt-in |
| Address, latitude / longitude | partial | ✅ |
| Main photo + direct booking URL | partial | ✅ |
| Server-side filters (price, stars, score, free-cancel, breakfast, property type) | ❌ | ✅ |
| **Price / availability monitoring** across runs | ❌ | ✅ |

### Use cases

- **Price & rate intelligence** — track nightly prices, taxes, discounts and availability across cities and dates for revenue management, OTAs, comparison sites and meta-search.
- **Market research** — benchmark a property against competitors by star class, review score, price band, free-cancellation and breakfast policy in any market.
- **Hotel monitoring** — schedule recurring runs and use monitor mode to capture only **price drops, price rises, sold-outs and newly available** hotels.
- **Travel content & aggregation** — feed booking sites, trip planners, dashboards and apps with structured, photo-rich hotel data for thousands of destinations.
- **Demand & event research** — watch how prices move around events, holidays and seasons in a destination.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Booking.com Scraper**, type a destination (e.g. `Paris`), pick your dates, and click **Start**.
3. Watch hotels stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "searchTerms": ["Paris", "Hotel Armoni Paris"],
    "checkInDate": "2026-07-15",
    "checkOutDate": "2026-07-17",
    "adults": 2,
    "rooms": 1,
    "currency": "USD",
    "sortBy": "price",
    "minPrice": 80,
    "maxPrice": 250,
    "starRatings": ["4"],
    "minReviewScore": 8,
    "freeCancellationOnly": true,
    "maxResultsPerSearch": 50,
    "maxResults": 200,
    "includeRooms": true
}
```

- **searchTerms** — destinations (`Paris`, `Bali`, `New York`, `Eiffel Tower`, `Schiphol Airport`) **or** specific hotel names (`Hotel Armoni Paris`). Each term is resolved with Booking's own autocomplete, so cities, regions, districts, landmarks, airports and individual hotels all work.
- **searchUrls** — paste Booking.com **search results** URLs (`https://www.booking.com/searchresults.html?ss=Rome&dest_id=-126693&dest_type=city...`) or **hotel** URLs (`https://www.booking.com/hotel/fr/armoni-paris.html`). Dates, occupancy and on-page filters in the URL are honoured.
- **destinations** *(advanced)* — explicit Booking IDs as `destId:destType` (e.g. `-1456928:city`, `735:landmark`, `10096:hotel`).
- **checkInDate / checkOutDate / adults / children / childrenAges / rooms** — used to price rooms and check availability (defaults to a 1-night stay 14 days out, 2 adults, 1 room).
- **currency / language** — currency (`USD`, `EUR`, `GBP`, …) and locale (`en-us`, `de`, `fr`, …) for all output.
- **sortBy** — `popularity`, `price`, `review_score_and_price`, `bayesian_review_score`, `class_descending`, `class_ascending`, `distance_from_search`.
- **Filters (server-side)** — `minPrice` / `maxPrice`, `starRatings`, `minReviewScore`, `freeCancellationOnly`, `breakfastIncludedOnly`, `propertyTypes`, plus `extraFilters` for raw Booking `nflt` codes. You only pay for results that match.
- **includeRooms** *(default true)* — include the per-offer `rooms` array.
- **monitorMode** — output only hotels that are **new** or whose **price / availability changed** since the last run.

### Output

One record per hotel (`type: "hotel"`):

```json
{
    "type": "hotel",
    "hotelId": 50845,
    "name": "Hotel Armoni Paris",
    "url": "https://www.booking.com/hotel/fr/armoni-paris.html",
    "pageName": "armoni-paris",
    "ufi": -1456928,
    "accommodationTypeId": 204,
    "isClosed": false,
    "starRating": 4,
    "starRatingType": "STARS",
    "reviewScore": 8.2,
    "reviewScoreLabel": "Very good",
    "reviewCount": 2034,
    "address": "7 Rue Greffulhe",
    "city": "Paris",
    "countryCode": "fr",
    "latitude": 48.8721,
    "longitude": 2.3245,
    "price": 272.79,
    "priceFormatted": "US$273",
    "currency": "USD",
    "pricePerNight": 136.4,
    "priceBeforeDiscount": 362.96,
    "discountAmount": 90.17,
    "discountPercent": 25,
    "taxesAndFees": "+US$39 taxes and fees",
    "available": true,
    "isSoldOut": false,
    "freeCancellation": true,
    "noPrepayment": false,
    "breakfastIncluded": false,
    "mealPlan": null,
    "roomName": "Standard Double Room",
    "bedrooms": 0,
    "bathrooms": 0,
    "beds": 1,
    "rooms": [
        { "name": "Standard Double Room", "price": 272.79, "currency": "USD", "originalPrice": 250.0, "originalCurrency": "EUR", "freeCancellationUntil": "2026-07-09T22:00:00Z", "mealPlan": null }
    ],
    "photoUrl": "https://cf.bstatic.com/xdata/images/hotel/square600/12345.webp",
    "checkIn": "2026-07-15",
    "checkOut": "2026-07-17",
    "nights": 2,
    "adults": 2,
    "children": 0,
    "roomsRequested": 1,
    "scrapedAt": "2026-06-18T12:00:00.000Z"
}
```

In **monitor mode** each emitted record also carries a `monitorChange` field: `new`, `price_drop`, `price_rise`, `sold_out` or `now_available`.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run hourly/daily/weekly to track prices or watch a destination for new hotels; perfect for price feeds and dashboards.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (price-alert email, Slack message, database import) the moment a run finishes.

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

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

const run = await client.actor('scrapesage/booking-scraper').call({
    searchTerms: ['Paris'],
    checkInDate: '2026-07-15',
    checkOutDate: '2026-07-17',
    currency: 'USD',
    maxResults: 50,
});

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

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push hotels and prices straight into your sheets or CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored destination has new hotels or price drops.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find 4-star hotels in Paris under $250 with free cancellation and a 8+ review score" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **travel & events** data stack:

- **[Airbnb Scraper & Market Monitor](https://apify.com/scrapesage/airbnb-scraper)** — vacation rentals: listings, prices, availability calendar and reviews.
- **[Eventbrite Scraper](https://apify.com/scrapesage/eventbrite-scraper)** — events with ticket prices and organizer contacts.
- **[Sched Conference Scraper](https://apify.com/scrapesage/sched-conference-scraper)** — conference speakers, sessions, sponsors and leads.
- **[Luma Scraper](https://apify.com/scrapesage/luma-scraper)** — Luma events, hosts and attendee-facing details.
- **[Swapcard Event Scraper](https://apify.com/scrapesage/swapcard-exhibitor-scraper)** — exhibitors, speakers and contacts from any public Swapcard event.

### Tips

- **Any destination**: type a city, region, landmark, airport or even a specific hotel name. Booking's autocomplete resolves it automatically — a hotel name returns just that property.
- **Prices need dates**: set `checkInDate`/`checkOutDate` for your exact stay. Without dates the actor prices a 1-night stay two weeks out.
- **Pay only for matches**: price, star, review-score, free-cancellation, breakfast and property-type filters are applied by Booking server-side, so filtered-out hotels are never returned (or billed).
- **Bigger sweeps**: raise `maxResultsPerSearch` to page deeper into a market; very large cities are best split by district (use several `searchUrls` with a `nflt` district filter).
- **Recurring price tracking**: combine [Schedules](https://docs.apify.com/platform/schedules) with `monitorMode` to emit only price drops, price rises, sold-outs and new hotels each run.
- **Proxies**: the default Apify datacenter (US) proxy works well; switch to residential if you scrape at very high volume.

### FAQ

**How do I scrape hotels for a specific city?** Put the city in `searchTerms` (e.g. `Bangkok`). For a precise market, paste a Booking.com search URL into `searchUrls` — its destination, dates and filters are honoured.

**Does it return live prices?** Yes — the lowest available room rate for your dates, plus the total taxes & fees text, any crossed-out "was" price and the discount %. Availability (sold-out) is detected too.

**Can I track a single hotel's price?** Yes — put the hotel name (or its Booking URL) in `searchTerms`/`searchUrls`, turn on `monitorMode`, and schedule the run. You'll get a record only when its price or availability changes.

**Can I filter results?** Yes — price range, star ratings, minimum review score, free cancellation, breakfast included and property type are all applied server-side. Power users can add raw Booking `nflt` codes via `extraFilters`.

**Can I export to Google Sheets, CSV or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**Does monitor mode conflict with Apify Schedules?** No. The schedule decides *when* the actor runs; monitor mode decides *what's emitted* (only new/changed hotels). They're complementary — use them together for price tracking.

**Is scraping Booking.com legal?** This actor collects publicly available hotel and pricing data only. You are responsible for using the data in compliance with applicable laws and Booking.com's terms.

**A field is null — why?** Some hotels genuinely don't publish a field (e.g. a brand-new property with no reviews, or no crossed-out price when there's no discount). Fields are `null` only when the data doesn't exist, not because the scraper skipped them.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `searchTerms` (type: `array`):

What to search. Type a <b>destination</b> (<code>Paris</code>, <code>Bali</code>, <code>New York</code>, <code>Eiffel Tower</code>, <code>Schiphol Airport</code>) to get all matching hotels, or a <b>specific hotel name</b> (<code>Hotel Armoni Paris</code>) to fetch just that property. Each term is resolved with Booking's own autocomplete, so cities, regions, districts, landmarks, airports and individual hotels all work.

## `searchUrls` (type: `array`):

Paste Booking.com <b>search results</b> URLs (<code>https://www.booking.com/searchresults.html?ss=Rome\&dest\_id=-126693\&dest\_type=city...</code>) or <b>hotel</b> URLs (<code>https://www.booking.com/hotel/fr/armoni-paris.html</code>). Dates, occupancy and on-page filters in the URL are honoured. Used in addition to the search terms above.

## `destinations` (type: `array`):

Advanced: explicit Booking destination IDs as <code>destId:destType</code> (e.g. <code>-1456928:city</code>, <code>735:landmark</code>, <code>10096:hotel</code>). Types: <code>city</code>, <code>region</code>, <code>country</code>, <code>district</code>, <code>airport</code>, <code>landmark</code>, <code>hotel</code>.

## `checkInDate` (type: `string`):

Check-in date (YYYY-MM-DD) used to price rooms and check availability. Defaults to 14 days from today.

## `checkOutDate` (type: `string`):

Check-out date (YYYY-MM-DD). Defaults to the day after check-in.

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

Number of adults for pricing.

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

Number of children for pricing.

## `childrenAges` (type: `array`):

Ages of children (0–17). If left empty when children > 0, age 8 is assumed for each child.

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

Number of rooms for pricing.

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

Currency for all prices (ISO code, e.g. <code>USD</code>, <code>EUR</code>, <code>GBP</code>, <code>AUD</code>).

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

Booking language/locale for text fields (e.g. <code>en-us</code>, <code>en-gb</code>, <code>de</code>, <code>fr</code>, <code>es</code>).

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

Result ordering.

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

Only return hotels at or above this nightly-stay price (in the chosen currency). 0 = no limit. Applied server-side.

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

Only return hotels at or below this price (in the chosen currency). 0 = no limit.

## `starRatings` (type: `array`):

Only return hotels with these star classes. Leave empty for all.

## `minReviewScore` (type: `integer`):

Only return hotels with a guest review score at or above this value (0–10). Maps to Booking's buckets (9+ Superb, 8+ Very good, 7+ Good, 6+ Pleasant).

## `minReviews` (type: `integer`):

Only keep hotels with at least this many guest reviews (applied client-side after fetching).

## `freeCancellationOnly` (type: `boolean`):

Only return stays that offer free cancellation.

## `breakfastIncludedOnly` (type: `boolean`):

Only return stays where breakfast is included.

## `propertyTypes` (type: `array`):

Only return these property types. Leave empty for all.

## `extraFilters` (type: `string`):

Advanced: raw Booking <code>nflt</code> filter codes, semicolon-separated, appended to the filters above (e.g. <code>hotelfacility=107;distance=1000</code>). Copy them from the <code>nflt=</code> part of a Booking search URL.

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

Include the <code>rooms</code> array (per available room offer: price, original price, free-cancellation deadline and meal plan).

## `maxResultsPerSearch` (type: `integer`):

Maximum hotels to collect for each destination / search URL.

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

Maximum number of hotels to scrape across all searches.

## `deduplicateResults` (type: `boolean`):

Skip a hotel if it was already emitted in this run (e.g. when it appears in two searches).

## `monitorMode` (type: `boolean`):

Remember each hotel's price and availability across runs (in a named key-value store) and output only hotels that are <b>new</b>, or whose <b>price changed</b> (price\_drop / price\_rise) or <b>availability changed</b> (sold\_out / now\_available). A <code>monitorChange</code> field is added to each record. Pair with Apify Schedules to track prices automatically. This does not conflict with the scheduler — the schedule triggers the run; monitor mode compares the run's results against earlier runs.

## `monitorStoreName` (type: `string`):

Named key-value store used to remember prices across runs. Use different names to track different searches independently (lowercase letters, digits and hyphens).

## `maxConcurrency` (type: `integer`):

How many destination resolutions to run in parallel.

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

Proxies to use. Apify Proxy (datacenter, US) works well for Booking.com's data host; switch to residential if you scrape at very high volume.

## Actor input object example

```json
{
  "searchTerms": [
    "Paris"
  ],
  "adults": 2,
  "children": 0,
  "rooms": 1,
  "currency": "USD",
  "language": "en-us",
  "sortBy": "popularity",
  "minPrice": 0,
  "maxPrice": 0,
  "minReviewScore": 0,
  "minReviews": 0,
  "freeCancellationOnly": false,
  "breakfastIncludedOnly": false,
  "includeRooms": true,
  "maxResultsPerSearch": 50,
  "maxResults": 200,
  "deduplicateResults": true,
  "monitorMode": false,
  "monitorStoreName": "booking-monitor",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped Booking.com hotel records as JSON items in the default dataset.

# 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 = {
    "searchTerms": [
        "Paris"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/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 = {
    "searchTerms": ["Paris"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/booking-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 '{
  "searchTerms": [
    "Paris"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapesage/booking-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/1dDPoLinx64gg9FDp/builds/yzZc6ePAUYYVSEzp4/openapi.json