# Booking.com Search Scraper (`w3crawler/booking-com-search-scraper`) Actor

Scrape hotel listings, prices, ratings, and detailed descriptions from Booking.com with support for search by location, specific hotel URLs, and deep details extraction.

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

## Pricing

from $2.99 / 1,000 hotel search results

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 does Booking.com Search Scraper do?

**Booking.com Search Scraper** collects public hotel and accommodation results from [Booking.com](https://www.booking.com/). It supports location searches, custom public search URLs, direct hotel URLs, optional detail-page enrichment, and an HTTP fallback for public HTML or JSON-LD responses. It is a practical **Booking.com API alternative** for travel research, rate comparison, and public property-data workflows.

The Actor only uses information exposed on public pages. It does not request private account data, bypass CAPTCHAs, or use protected endpoints. When a target cannot produce a source-backed hotel row, the Actor records the reason in the run log and reports counts in the `OUTPUT` summary.

### Why use Booking.com Search Scraper?

- Search by city or region, submit an existing public search URL, or provide public hotel URLs.
- Capture public names, prices, review scores, distances, images, cancellation and meal indicators when displayed.
- Enable deep scraping for descriptions, amenities, room offers, policies, coordinates, nearby landmarks, transportation, sustainability text, and review highlights.
- Keep source and extraction provenance on every record, including the browser or HTTP fallback path.
- Run on Apify with scheduling, API access, webhooks, proxy configuration, monitoring, and integrations.

### What data can it extract?

| Field | Type | Description |
| --- | --- | --- |
| `name`, `url`, `hotelId` | string | Public property identity and URL-derived identifier. |
| `price`, `priceAmount`, `priceCurrency`, `originalPrice` | string/number | Public displayed price, parsed amount, inferred display currency, and optional original price. |
| `reviewScore`, `reviewCategory`, `reviewsCount` | string/number | Public guest-review information. |
| `starRating` | integer | Public hotel class in stars. |
| `address`, `distance`, `thumbnail` | string | Public location and search-card information. |
| `amenities`, `rooms`, `images` | array | Optional detail-page enrichment. |
| `scrapedAt` | string | UTC timestamp for the emitted row. |

The dataset schema also preserves useful legacy aliases such as `rating`, `reviewCount`, `location`, `distanceFromCenter`, `badge`, `rawText`, and `priceAvailable`.

### How to scrape Booking.com

1. Open the Actor and choose `search`, `hotelUrl`, or `searchUrl` in the input tab.
2. For `search`, enter a city or region. Add check-in and check-out dates when you need date-specific public prices.
3. Set `maxItems` and choose whether to enable `deepScraping` and `includeReviews`.
4. Direct public requests are used by default. Configure a proxy only when explicitly needed for your lawful public-data use case.
5. Start the run and inspect source-backed hotel rows in the dataset. Target failures and clean empty results are described in the run log and `OUTPUT` summary.

### How much does it cost?

The Actor uses Apify compute units and any proxy resources selected for the run. Search-only runs are generally lighter than detail-enriched runs because deep scraping visits individual property pages. Keep `maxItems` low while developing, and disable `deepScraping` when you only need search-card data. Exact cost depends on browser time, retries, concurrency, page complexity, and proxy usage.

### Input

See the input tab for full configuration options. The main inputs are `mode`, `searchQuery`, `hotelUrls`, `searchUrl`, `checkInDate`, `checkOutDate`, `adults`, `children`, `rooms`, `currency`, `language`, `maxItems`, `deepScraping`, `includeReviews`, `headless`, and `proxyConfiguration`.

`hotelUrls` should contain public Booking.com hotel URLs. `searchUrl` should be a complete public search URL with its desired filters. `maxItems` accepts 1–1000 and counts source-backed hotel rows; unavailable targets do not consume that count.

When dates are omitted, the Actor generates a one-night stay beginning 30 days in the future so search results can expose current public prices.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. A simplified successful output looks like this:

```json
[
  {
    "name": "Example Central Hotel",
    "price": "US$245",
    "priceAmount": 245,
    "priceCurrency": "USD",
    "reviewScore": "8.4",
    "url": "https://www.booking.com/hotel/fr/example-central-hotel.html",
    "scrapedAt": "2026-09-08T00:00:00.000Z"
  }
]
```

The `OUTPUT` key-value-store record includes required `status`, `runStatus`, and `dataStatus` fields plus `datasetItems`, `diagnosticItems`, `uniqueItems`, and `failureCount`. Failure details remain in the run log. A clean empty result is `SUCCEEDED` with `dataStatus: NO_RESULTS`; a failure after saved rows is `SUCCEEDED` with `dataStatus: PARTIAL`.

### Tips and advanced options

- Start with `deepScraping: false` to confirm search-card coverage, then enable detail enrichment.
- Supply dates and currency for more meaningful public price text.
- Use `includeReviews: true` only when review snippets are needed; it increases page work.
- Treat missing optional fields as normal. Booking.com may not expose address, cancellation, breakfast, or room details on every locale or property page.

### FAQ, disclaimers, and support

#### Does this Actor bypass CAPTCHAs or private access controls?

No. The Actor stops its current path when a public access barrier is detected and reports it in the run log. It does not bypass CAPTCHAs, paywalls, login walls, geofences, rate limits, device checks, or WAF controls.

#### Is the output personal data?

Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

Use the Issues tab for feedback and the API tab for programmatic access. You are responsible for complying with Booking.com terms, applicable law, robots guidance, and any restrictions that apply to your use case.

# Changelog

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

# Actor input Schema

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

Select the type of input: search by location, direct hotel URLs, or a custom search URL.

## `searchQuery` (type: `string`):

City or region to search for hotels (e.g., 'Paris', 'New Delhi'). Used when mode is 'search'.

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

Compatibility alias for searchQuery.

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

Optional public Booking.com hotel or search-result URLs. The mode is inferred when omitted.

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

Check-in date in YYYY-MM-DD format. When omitted, the Actor uses a date 30 days in the future.

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

Compatibility alias for checkInDate.

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

Check-out date in YYYY-MM-DD format. When omitted, the Actor uses the day after the generated check-in date.

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

Compatibility alias for checkOutDate.

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

Number of adult guests.

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

Number of children guests.

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

Compatibility input; the number of entries is used as the child count.

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

Number of rooms to book.

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

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

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

Language code for the Booking.com interface (e.g. en-gb, en-us, de, fr).

## `hotelUrls` (type: `array`):

Array of Booking.com hotel page URLs. Used when mode is 'hotelUrl'.

## `searchUrl` (type: `string`):

Full Booking.com search URL with all filters already applied. Used when mode is 'searchUrl'.

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

Maximum number of hotels to scrape (1-1000).

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

Compatibility alias for maxItems.

## `deepScraping` (type: `boolean`):

Visit each hotel page to extract full details: description, amenities, rooms, policies, images, coordinates, and more.

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

Compatibility flag; false disables deep detail scraping.

## `includeReviews` (type: `boolean`):

Extract up to 5 guest review text snippets from each hotel page.

## `headless` (type: `boolean`):

Run browser in headless mode (recommended for production).

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

Optional proxy settings. Direct public requests are used by default.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "Paris",
  "adults": 2,
  "children": 0,
  "rooms": 1,
  "currency": "USD",
  "language": "en-gb",
  "maxItems": 20,
  "deepScraping": true,
  "includeRooms": true,
  "includeReviews": false,
  "headless": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing source-backed hotel records only.

## `runSummary` (type: `string`):

Final source-row, unavailable-target, and failure counts plus input provenance.

# 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 = {
    "searchQuery": "Paris",
    "maxItems": 20,
    "deepScraping": true,
    "headless": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("w3crawler/booking-com-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 = {
    "searchQuery": "Paris",
    "maxItems": 20,
    "deepScraping": True,
    "headless": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("w3crawler/booking-com-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 '{
  "searchQuery": "Paris",
  "maxItems": 20,
  "deepScraping": true,
  "headless": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call w3crawler/booking-com-search-scraper --silent --output-dataset

```

## MCP server setup

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