# Booking.com Reviews Scraper — Hotel Reviews & Ratings (`zhorex/booking-reviews-scraper`) Actor

Extract hotel reviews from Booking.com with full details: scores, positive/negative text, reviewer nationality, traveler type, room info, and hotel responses. Fast, reliable, and clean output.

- **URL**: https://apify.com/zhorex/booking-reviews-scraper.md
- **Developed by:** [Sami](https://apify.com/zhorex) (community)
- **Categories:** Travel, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Reviews Scraper — Fast, Clean & Reliable

Extract hotel reviews from Booking.com with full details: review scores, positive and negative text, reviewer nationality, traveler type, room info, hotel responses, and more.

### What it does

This scraper takes one or more Booking.com hotel URLs and extracts all guest reviews with structured, clean data. Each review includes the score, written feedback (positive and negative), reviewer details, stay information, and the hotel's response if available.

### Why this scraper?

- **Reliable extraction** — Robust error handling and multiple selector fallbacks ensure consistent results even when Booking.com updates their HTML
- **Clean, structured output** — Every field is parsed and normalized (dates in ISO format, scores as numbers, traveler types standardized)
- **Full review details** — Not just text and score, but also room type, number of nights, check-in date, reviewer country, and hotel management responses
- **Smart pagination** — Automatically navigates through all review pages with anti-detection measures
- **Flexible filtering** — Filter by language, score range, traveler type, and sort order

### What you get per review

| Field | Example | Description |
|-------|---------|-------------|
| `reviewScore` | `9.2` | Individual review score (1-10) |
| `reviewTitle` | `"Amazing stay!"` | Review headline |
| `reviewPositive` | `"Beautiful room, great location..."` | Positive feedback text |
| `reviewNegative` | `"Breakfast could be better"` | Negative feedback text |
| `reviewDate` | `"2026-03-15"` | Date of the review (ISO format) |
| `reviewerName` | `"John"` | Reviewer's display name |
| `reviewerCountry` | `"United States"` | Reviewer's country |
| `reviewerTravelerType` | `"couple"` | solo, couple, family, group, business |
| `reviewerRoomType` | `"Deluxe Double Room"` | Room type booked |
| `reviewerNights` | `3` | Number of nights stayed |
| `reviewerCheckIn` | `"2026-03-12"` | Check-in date |
| `reviewLanguage` | `"en"` | Language of the review |
| `hotelResponseText` | `"Thank you for your kind words..."` | Hotel's response to the review |
| `hotelResponseDate` | `"2026-03-16"` | Date of hotel's response |
| `hotelName` | `"Hotel Example Barcelona"` | Hotel name |
| `hotelOverallScore` | `8.6` | Hotel's overall score |
| `hotelTotalReviews` | `1243` | Total number of reviews |
| `hotelLocation` | `"Barcelona, Spain"` | Hotel location |
| `hotelStars` | `4` | Hotel star rating |

### Use cases

- **Competitive analysis** — Compare guest sentiment across hotels in a market
- **Revenue management** — Track how pricing changes affect guest satisfaction
- **Market research** — Understand traveler preferences by nationality, type, and season
- **Sentiment analysis** — Run NLP on review text to identify trends and pain points
- **Travel tech** — Build recommendation engines or review aggregators

### Input example

```json
{
    "hotelUrls": [
        "https://www.booking.com/hotel/es/ayre-gran-via.html",
        "https://www.booking.com/hotel/fr/le-marais.html"
    ],
    "maxReviewsPerHotel": 200,
    "filterByLanguage": "en",
    "sortBy": "newest",
    "includeHotelInfo": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
````

### Output example

```json
{
    "hotelUrl": "https://www.booking.com/hotel/es/ayre-gran-via.html",
    "hotelName": "Ayre Hotel Gran Via",
    "hotelLocation": "Barcelona, Spain",
    "hotelOverallScore": 8.4,
    "hotelTotalReviews": 2847,
    "hotelStars": 4,
    "reviewTitle": "Perfect location for exploring Barcelona",
    "reviewPositive": "Right next to Plaza Espanya, amazing rooftop pool, very clean rooms with modern design. Staff was incredibly helpful with restaurant recommendations.",
    "reviewNegative": "Street noise at night if your room faces the main road. Ask for a courtyard room.",
    "reviewScore": 8.8,
    "reviewDate": "2026-03-20",
    "reviewerName": "Sarah",
    "reviewerCountry": "United Kingdom",
    "reviewerTravelerType": "couple",
    "reviewerRoomType": "Superior Double Room",
    "reviewerNights": 4,
    "reviewerCheckIn": "2026-03-16",
    "reviewLanguage": "en",
    "hotelResponseText": "Dear Sarah, thank you for choosing our hotel. We are glad you enjoyed the rooftop pool and our staff's service. Regarding the noise, we do offer courtyard-facing rooms upon request.",
    "hotelResponseDate": "2026-03-22",
    "scrapedAt": "2026-04-06T14:32:00.000Z"
}
```

### Pricing

This scraper uses **Pay Per Event** pricing:

| Event | Price |
|-------|-------|
| Per review extracted | $0.002 |

**Examples:**

- 100 reviews = $0.20
- 500 reviews = $1.00
- 1,000 reviews = $2.00

You are only charged for reviews that are successfully extracted. If a hotel has no reviews or the scrape fails, you are not charged.

### Filters available

- **By language** — Use ISO language codes: `en`, `es`, `fr`, `de`, `it`, `pt`, `nl`, `ja`, `zh`, `ko`, `ru`, `ar`
- **By score** — `low` (1-3), `medium` (4-6), `high` (7-10), or `all`
- **By traveler type** — `solo`, `couple`, `family`, `group`, `business`
- **Sort order** — `newest`, `oldest`, `highest_score`, `lowest_score`

### Limitations

- **Rate limits** — The scraper respects Booking.com's rate limits with built-in delays between pages (2-5 seconds) and between hotels (3-5 seconds)
- **Proxy required** — Residential proxies are strongly recommended. The scraper uses Apify's residential proxy by default
- **Max reviews** — Up to 5,000 reviews per hotel. Most hotels have fewer than this
- **CAPTCHA** — Booking.com may occasionally show CAPTCHAs. The scraper logs a warning and skips if this happens
- **Page structure changes** — Booking.com may update their HTML. The scraper uses multiple fallback selectors, but if extraction stops working, please report it

### FAQ

**Does it work with any hotel on Booking.com?**
Yes, any publicly listed hotel with reviews on Booking.com.

**What languages are supported?**
All languages available on Booking.com. You can filter reviews by language or get all languages at once.

**Is the hotel's response to reviews included?**
Yes, if the hotel has responded to a review, both the response text and date are extracted.

**Can I scrape thousands of reviews?**
Yes, up to 5,000 per hotel. For hotels with many reviews, set `maxReviewsPerHotel` to your desired limit.

**How fast is it?**
Approximately 3-5 seconds per page of reviews (10 reviews per page). A hotel with 200 reviews takes about 1-2 minutes.

**What if a hotel has no reviews?**
The scraper will log a warning and move to the next hotel. No charge is applied.

# Actor input Schema

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

List of Booking.com hotel URLs to scrape reviews from. Accepts full URLs (https://www.booking.com/hotel/es/example.html) or paths (/hotel/es/example.html).

## `maxReviewsPerHotel` (type: `integer`):

Maximum number of reviews to extract per hotel. Set to 0 for unlimited (up to 5,000).

## `filterByScore` (type: `string`):

Filter reviews by score range. Leave empty for all scores.

## `filterByLanguage` (type: `string`):

Filter reviews by language using ISO code (en, es, fr, de, it, pt, nl, ja, zh, ko, ru, ar). Leave empty for all languages.

## `filterByTravelerType` (type: `string`):

Filter reviews by type of traveler.

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

How to sort the reviews.

## `includeHotelInfo` (type: `boolean`):

Include hotel metadata (name, overall score, location, stars) with each review.

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

Proxy settings. Residential proxies are recommended for Booking.com.

## Actor input object example

```json
{
  "hotelUrls": [
    "https://www.booking.com/hotel/es/ayre-gran-via.html"
  ],
  "maxReviewsPerHotel": 100,
  "sortBy": "newest",
  "includeHotelInfo": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "hotelUrls": [
        "https://www.booking.com/hotel/es/ayre-gran-via.html"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zhorex/booking-reviews-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 = { "hotelUrls": ["https://www.booking.com/hotel/es/ayre-gran-via.html"] }

# Run the Actor and wait for it to finish
run = client.actor("zhorex/booking-reviews-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 '{
  "hotelUrls": [
    "https://www.booking.com/hotel/es/ayre-gran-via.html"
  ]
}' |
apify call zhorex/booking-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booking.com Reviews Scraper — Hotel Reviews & Ratings",
        "description": "Extract hotel reviews from Booking.com with full details: scores, positive/negative text, reviewer nationality, traveler type, room info, and hotel responses. Fast, reliable, and clean output.",
        "version": "1.0",
        "x-build-id": "2PATojennaTVIXZnr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zhorex~booking-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zhorex-booking-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/zhorex~booking-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-zhorex-booking-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/zhorex~booking-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-zhorex-booking-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "hotelUrls"
                ],
                "properties": {
                    "hotelUrls": {
                        "title": "Hotel URLs",
                        "type": "array",
                        "description": "List of Booking.com hotel URLs to scrape reviews from. Accepts full URLs (https://www.booking.com/hotel/es/example.html) or paths (/hotel/es/example.html).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerHotel": {
                        "title": "Max Reviews Per Hotel",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of reviews to extract per hotel. Set to 0 for unlimited (up to 5,000).",
                        "default": 100
                    },
                    "filterByScore": {
                        "title": "Filter by Score",
                        "enum": [
                            "all",
                            "low",
                            "medium",
                            "high"
                        ],
                        "type": "string",
                        "description": "Filter reviews by score range. Leave empty for all scores."
                    },
                    "filterByLanguage": {
                        "title": "Filter by Language",
                        "type": "string",
                        "description": "Filter reviews by language using ISO code (en, es, fr, de, it, pt, nl, ja, zh, ko, ru, ar). Leave empty for all languages."
                    },
                    "filterByTravelerType": {
                        "title": "Filter by Traveler Type",
                        "enum": [
                            "solo",
                            "couple",
                            "family",
                            "group",
                            "business"
                        ],
                        "type": "string",
                        "description": "Filter reviews by type of traveler."
                    },
                    "sortBy": {
                        "title": "Sort Reviews By",
                        "enum": [
                            "newest",
                            "oldest",
                            "highest_score",
                            "lowest_score"
                        ],
                        "type": "string",
                        "description": "How to sort the reviews.",
                        "default": "newest"
                    },
                    "includeHotelInfo": {
                        "title": "Include Hotel Info",
                        "type": "boolean",
                        "description": "Include hotel metadata (name, overall score, location, stars) with each review.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxies are recommended for Booking.com.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
