# Booking Scraper PRO (`khadinakbar/booking-scraper-pro`) Actor

Scrape Booking.com hotels and properties with prices, review scores, stars, location and amenities. Search any city or paste Booking.com URLs.

- **URL**: https://apify.com/khadinakbar/booking-scraper-pro.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Travel, MCP servers, AI
- **Features:** Limited permissions
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 property scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 is Booking Scraper PRO?

Booking Scraper PRO returns one dataset row per Booking.com property from a destination search or from Booking.com URLs: property name, link and ID, guest review score with its label and review count, star class, area and distance from the centre, deal flags, main photo and, for dated searches, the nightly price in your chosen currency. Hotel revenue managers, travel analysts, agencies and AI agents use it to map supply in a city, benchmark competitors on rating and price, and build property lists, with optional detail enrichment for descriptions, amenities and coordinates.

### Why travel teams use this Booking.com scraper

- **Search like a guest.** `search` takes a destination such as `Amsterdam`; `checkIn`, `checkOut`, `adults`, `children` and `rooms` set the stay.
- **Prices in your currency.** `currency` covers 18 currencies and `language` sets the Booking locale.
- **Ratings ready to rank.** `reviewScore`, `reviewScoreWord` and `reviewCount` sit on every rated property.
- **Filters before collection.** `minPrice`, `maxPrice` and `minStars` narrow the search on Booking.com itself.
- **Detail on demand.** `enrichDetails` opens each property page for `description`, `amenities`, check-in and check-out times and coordinates.
- **URLs welcome.** `startUrls` accepts Booking.com search pages and individual property pages.

### Best fit for this Actor

- Best fit for competitor sets, destination supply maps and rating benchmarks across Booking.com properties.
- Designed for dated searches when price matters: Booking.com shows nightly prices for a specific stay, so set `checkIn` and `checkOut` to fill `price`, `priceText` and `taxesAndFees`. Undated searches return names, scores and locations.
- For full-city coverage, run several focused searches, such as by district, star class or price band, and merge the datasets on `hotelId`.
- When you want what guests actually wrote, then pass the property `url` values to [Booking.com Reviews Scraper](https://apify.com/khadinakbar/booking-reviews-scraper).
- To compare the same hotels on another platform, continue with [TripAdvisor Scraper](https://apify.com/khadinakbar/tripadvisor-scraper).

### Example workflow: from a city search to a rate benchmark

A revenue manager at a boutique hotel in Amsterdam starts with `search` set to `Amsterdam`, a weekend `checkIn` and `checkOut`, `currency` set to `EUR`, `minStars` at 4 and `maxResults` at 50. The dataset returns each competitor's `price`, `reviewScore`, `reviewCount` and `distanceFromCenter`. They keep properties within a mile of their own, compare price against `reviewScore` to see who charges a premium for ratings, and export the table to their pricing sheet. They then schedule the same input for each upcoming weekend and compare rates week over week.

### Input

```json
{
  "search": "Amsterdam",
  "checkIn": "2026-11-13",
  "checkOut": "2026-11-15",
  "adults": 2,
  "children": 0,
  "rooms": 1,
  "currency": "EUR",
  "language": "en-gb",
  "minStars": 4,
  "maxResults": 50,
  "enrichDetails": false
}
```

| Field | Type | What it controls |
|---|---|---|
| `search` | string | Destination to search, such as `Amsterdam` or `Paris, France`. Use this or `startUrls`. |
| `startUrls` | array | Booking.com search-results URLs or individual property URLs. |
| `checkIn`, `checkOut` | strings | Stay dates in `YYYY-MM-DD` format, for nightly prices. |
| `adults`, `children`, `rooms` | integers | Occupancy. Defaults 2, 0 and 1. |
| `currency` | string | Price currency, such as `USD`, `EUR` or `GBP`. Default `USD`. |
| `language` | string | Booking locale, such as `en-gb`, `de` or `fr`. Default `en-gb`. |
| `minPrice`, `maxPrice` | integers | Nightly price range in the selected currency. |
| `minStars` | integer | Minimum star class, 0 to 5. Default 0. |
| `maxResults` | integer | Cap on properties saved, up to 1,000. Default 25. |
| `enrichDetails` | boolean | Open each property page for description, amenities, times and coordinates. Default `false`. |
| `proxyConfiguration` | object | Apify Proxy settings. Default uses Apify Proxy. |

### Output

One row per property. Fields stay `null` when Booking.com leaves them off the card or the search.

| Field | What it contains |
|---|---|
| `name`, `url`, `hotelId` | Property identity and link |
| `reviewScore`, `reviewScoreWord`, `reviewCount` | Guest rating on a 0 to 10 scale, its label and review count |
| `stars` | Star class when Booking.com shows one |
| `price`, `currency`, `priceText`, `taxesAndFees` | Nightly price for dated searches |
| `address`, `city`, `country`, `distanceFromCenter` | Location from the property card; on city searches `city` holds the district and `country` the city |
| `roomType`, `bedConfig` | The room offered for the stay |
| `freeCancellation`, `breakfastIncluded`, `badges` | Deal flags |
| `image` | Main photo URL |
| `propertyType`, `description`, `amenities`, `checkInTime`, `checkOutTime`, `latitude`, `longitude` | Detail fields with `enrichDetails` |
| `checkInDate`, `checkOutDate`, `scrapedAt` | Stay dates searched and collection time |

Example row from an undated Amsterdam search:

```json
{
  "name": "Holiday Inn Express Amsterdam - North Riverside by IHG",
  "url": "https://www.booking.com/hotel/nl/holiday-inn-express-amsterdam-motorkade.en-gb.html",
  "hotelId": "holiday-inn-express-amsterdam-motorkade",
  "propertyType": null,
  "reviewScore": 8.2,
  "reviewScoreWord": "Very good",
  "reviewCount": 12546,
  "stars": null,
  "price": null,
  "currency": "USD",
  "priceText": null,
  "address": "Amsterdam Noord, Amsterdam",
  "city": "Amsterdam Noord",
  "country": "Amsterdam",
  "distanceFromCenter": "1.4 miles from centre",
  "freeCancellation": false,
  "breakfastIncluded": false,
  "badges": [],
  "image": "https://cf.bstatic.com/xdata/images/hotel/square240/269458643.webp?k=519e81855baad947382232b5ab719093f75caf08430bce8225d07d850638134e&o=",
  "checkInDate": null,
  "checkOutDate": null,
  "scrapedAt": "2026-10-01T13:02:43.323Z"
}
```

### Pricing

This Actor uses Pay per event plus Apify platform usage. Each property saved is one **Property scraped** event; with `enrichDetails` on, each property also adds one **Property detail enrichment** event. Every run has one **Actor Start** event plus the platform usage of the run. For example, 50 properties without enrichment are 50 Property scraped events plus the start event and usage; with enrichment they are 50 of each. `maxResults` caps the count, so it doubles as a spending limit. The live Pricing tab on this page shows the current event prices.

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~booking-scraper-pro/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"search": "Lisbon", "checkIn": "2026-11-13", "checkOut": "2026-11-15", "currency": "EUR", "maxResults": 25}'
```

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("khadinakbar/booking-scraper-pro").call(run_input={"search": "Rome", "minStars": 4, "maxResults": 30})
rated = [p for p in client.dataset(run["defaultDatasetId"]).iterate_items() if p.get("reviewScore")]
print(sorted(rated, key=lambda p: p["reviewScore"], reverse=True)[:10])
```

### Use with AI agents (MCP)

Connect the Actor to Claude, ChatGPT or Cursor through [Apify MCP](https://mcp.apify.com) and ask:

> Find 4-star hotels in Rome for two adults from 13 to 15 November, priced in euros. List the ten best rated with their nightly price and distance from the centre.

The agent sets `search`, `checkIn`, `checkOut`, `currency`, `minStars` and `maxResults`, reads rows with `get-dataset-items`, sorts by `reviewScore`, and cites each `url`. Each property is one event, so `maxResults` keeps the cost of the request predictable.

### Best results

| Starting situation | Helpful action | Expected outcome |
|---|---|---|
| Rate shopping | Set `checkIn`, `checkOut` and `currency` | Nightly prices with taxes and fees |
| A big city | Split into district or star-band searches | Wider coverage across runs |
| Rating benchmarks | Sort by `reviewScore`, then `reviewCount` | Well-reviewed properties first |
| Amenity or description checks | Turn on `enrichDetails` | Description, amenities and coordinates |
| A known competitor set | Paste property pages into `startUrls` | Exactly those properties |

### Builder's note

I built this for the revenue-manager question of who charges what next to whom, so every row pairs rating, location and, for dated searches, price. I kept detail enrichment optional because most benchmarking only needs the search card, and opening every property page is the slow, extra-cost step.

### FAQ

#### Why is the price empty?

Booking.com shows nightly prices for a specific stay. Add `checkIn` and `checkOut` to the input.

#### Can I get guest reviews?

This Actor returns scores and review counts. For review text, use the property URLs with the Booking.com Reviews Scraper linked above.

#### How do I cover a whole city?

Run several focused searches and merge them on `hotelId`.

### Responsible use

This Actor collects publicly available Booking.com property data. Respect Booking.com's terms and applicable laws such as the GDPR when you store or share results. Booking.com is a trademark of its owner; this independent Actor is not affiliated with or endorsed by Booking.com.

# Changelog

This Actor's version history is a separate document: https://apify.com/khadinakbar/booking-scraper-pro/changelog.md

# Actor input Schema

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

Free-text destination to search on Booking.com, e.g. 'Amsterdam', 'Paris, France', or 'Bali'. Use this when you want every matching property for a place. Leave empty if you instead paste exact URLs in Start URLs. NOT a hotel name on its own — for one specific hotel paste its URL in Start URLs.

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

Booking.com search-results URLs or individual hotel URLs to scrape directly (e.g. 'https://www.booking.com/searchresults.html?ss=Rome' or 'https://www.booking.com/hotel/nl/jerome.html'). Use this when you already have a filtered Booking URL or specific hotels. Each item is auto-detected as a search page or a hotel page. NOT for non-Booking.com domains — those are skipped.

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

Check-in date in YYYY-MM-DD format, e.g. '2026-07-10'. Use together with Check-out to get live, date-specific room prices. If left empty, Booking.com returns indicative prices without a fixed stay. Must be paired with Check-out — a check-in alone is ignored by Booking.com.

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

Check-out date in YYYY-MM-DD format, e.g. '2026-07-12'. Must be after Check-in and paired with it for accurate nightly prices. If empty, prices are indicative only. NOT a number of nights — provide the actual calendar date.

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

Number of adult guests used to compute room availability and price, e.g. 2. Defaults to 2 when omitted. Affects which rooms and prices Booking.com returns. NOT the number of rooms — set that separately in Rooms.

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

Number of child guests included in the occupancy, e.g. 0 or 2. Defaults to 0. Some properties price or filter differently when children are present. Does not set children ages (Booking.com assumes a default age).

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

Number of rooms requested, e.g. 1. Defaults to 1. Increasing this changes which properties have availability and their total price. NOT the same as guests — set guest counts in Adults and Children.

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

ISO currency code that prices are returned in, e.g. 'USD', 'EUR', 'GBP'. Defaults to USD. Booking.com converts displayed prices to this currency. Use a 3-letter code, not a symbol.

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

Booking.com locale that controls page language and the domain variant used, e.g. 'en-gb', 'en-us', 'de', 'fr'. Defaults to en-gb. Affects review wording and some field text. Use a Booking locale code, not a country name.

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

Lower bound for nightly price in the selected currency, e.g. 50. Leave empty for no minimum. Applied as a Booking.com price filter on the search. Has no effect on direct hotel URLs.

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

Upper bound for nightly price in the selected currency, e.g. 300. Leave empty for no maximum. Applied as a Booking.com price filter on the search. Has no effect on direct hotel URLs.

## `minStars` (type: `integer`):

Filter to properties with at least this hotel-class star rating, 1-5 (e.g. 4 = 4 stars and up). Set 0 (default) for no star filter. This is the official property star class, NOT the guest review score (which is 0-10).

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

Hard cap on properties scraped and billed per search, e.g. 25. Defaults to 25 (Booking.com's first results page, which is rock-solid). Higher values trigger best-effort infinite-scroll to load more, but Booking throttles this — for guaranteed large datasets, run several narrower searches (by city area, star class, or price band). Lower it to control cost.

## `enrichDetails` (type: `boolean`):

When true, the actor opens each property page to add description, full amenities, check-in/out times, and precise coordinates. This is slower and adds a per-property detail charge. Leave false for fast listing-only scraping. Off by default.

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

Proxy settings. Defaults to Apify Proxy (datacenter), which works on Booking.com with the actor's browser engine. If you have RESIDENTIAL proxy access and hit blocks, switch the group here. Set a country for geo-specific pricing.

## Actor input object example

```json
{
  "search": "Paris, France",
  "startUrls": [],
  "checkIn": "2026-07-10",
  "checkOut": "2026-07-12",
  "adults": 2,
  "children": 0,
  "rooms": 1,
  "currency": "USD",
  "language": "en-gb",
  "minStars": 0,
  "maxResults": 25,
  "enrichDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `properties` (type: `string`):

No description

## `summary` (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 = {
    "search": "Amsterdam"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/booking-scraper-pro").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 = { "search": "Amsterdam" }

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/booking-scraper-pro").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 '{
  "search": "Amsterdam"
}' |
apify call khadinakbar/booking-scraper-pro --silent --output-dataset

```

## MCP server setup

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

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/4zLe5gvKZTLYlaZiO/builds/4XyWT0uXP8OyFtaQP/openapi.json