# Booking.com Reviews Scraper: All Reviews, Fast, from $0.50/1K (`alexmorain/booking-reviews-scraper`) Actor

Scrape Booking.com guest reviews of any property: score, title, liked and disliked text, room, nights, stay dates, traveller type, country and property reply, plus address, coordinates and score. Reviews read over HTTP, no page limit, ids cached. New-reviews-only monitoring and webhook.

- **URL**: https://apify.com/alexmorain/booking-reviews-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Travel, Marketing, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Reviews Scraper do?

Booking.com Reviews Scraper exports the guest reviews of any property on [Booking.com](https://www.booking.com): score out of 10, title, what the guest liked and disliked, language, room, number of nights, check-in and check-out dates, traveller type, country and the property's reply. Paste property URLs, get one row per review plus one summary row per property with its address, coordinates, stars and overall score.

It works as a **Booking.com reviews API**. Booking protects its pages with a bot check, so most tools open every property in a full browser. This actor reads the reviews from Booking's data endpoint in plain HTTP, and only uses a browser for a few seconds to find the id of a property you give by URL (paste the numeric hotel id and no browser runs at all). Ids are cached for later runs.

#### Fast on the largest properties

Measured on 21 October 2026, from Apify servers:

| Property | Reviews on Booking.com | Collected | Time |
|---|---|---|---|
| Park Plaza London Westminster Bridge | 22,271 | 22,271 | about 2 minutes |
| Hotel Le Six, Paris | 576 | 576 | 3 seconds |

There is no page limit: the actor reads to the last review Booking shows. Booking.com itself only shows reviews from the last 36 months, so that is the history you get.

### Why use Booking.com Reviews Scraper?

- Reputation monitoring for hotels and apartments: schedule it in **New reviews only** mode and get only the reviews published since the last run, with a webhook to Slack, Make, Zapier or n8n.
- Competitor research: read what guests dislike at the properties around yours, in their own words, with liked and disliked text in separate columns.
- Revenue and product decisions: see which rooms, traveller types and nationalities score lower.
- Sentiment analysis and LLM pipelines: clean text, language code and score per review.

Apify adds scheduling, an API for every run, integrations with Google Sheets, Slack, Zapier and Make, and exports to JSON, CSV and Excel.

### What data can Booking.com Reviews Scraper extract?

| Field | Example | Description |
|---|---|---|
| `rating` | `9.0` | Guest score, out of 10 |
| `title` | `Perfectly located` | Review title |
| `positiveText`, `negativeText` | `Quiet street, great breakfast` | What the guest liked and disliked |
| `language` | `fr` | Language of the review |
| `publishedAt` | `2026-08-15T19:37:19Z` | Review date |
| `checkinDate`, `checkoutDate`, `nights` | `2026-08-10`, `2026-08-15`, `5` | The stay |
| `roomType` | `Classic Double Room` | Room booked |
| `travelerType` | `COUPLES` | Couples, families, groups of friends, solo or business travellers |
| `reviewerName`, `reviewerLocation`, `reviewerCountryCode` | `Claire`, `France`, `FR` | First name and country, as Booking shows them |
| `ownerResponse` | `Dear Claire, thank you...` | The property's reply |
| `photos` | | Guest photo URLs, when any |
| `placeName`, `placeId`, `placeUrl` | `Hotel Le Six`, `58824` | The property |

The summary row adds the address, city, country, latitude and longitude, star rating, the overall Booking score and the number of reviews.

### How to scrape Booking.com reviews

1. Click **Try for free**.
2. In **Page URLs**, paste Booking.com property URLs such as `https://www.booking.com/hotel/fr/le-six.html`, or numeric hotel ids.
3. Set **Max reviews per page URL**. `0` collects every review.
4. Optionally keep only some languages or traveller types, or only the last N days.
5. Click **Start**, then download the results as JSON, CSV or Excel.

### How much will it cost to scrape Booking.com reviews?

You pay per result:

- $1.00 per 1,000 reviews on the Apify Free plan, going down with your plan to $0.50 per 1,000 on Gold and above;
- $0.002 per summary row ($0.001 on Gold), which you can turn off;
- $0.005 when the run starts.

The $5 of monthly credit in the Apify Free plan covers about 5,000 reviews. All 22,271 reviews of Park Plaza Westminster Bridge cost about $22 on the Free plan and $11 on Gold. A daily monitoring run on one property with a few new reviews costs about one cent.

### Input

See the **Input** tab for every option. The ones worth knowing:

- **Page URLs**: property URLs (language suffixes and query strings are fine) or numeric hotel ids. Ids skip the page lookup and start faster.
- **Review languages**: codes such as `en`, `fr`, `de`. Empty means all languages.
- **Traveller types**: families, couples, solo, business, friends, filtered by Booking itself.
- **Only reviews from the last N days** or **Only reviews published after**: the actor reads newest first and stops once it passes the date.
- **Review mode**: `New reviews only` keeps a registry per property and never returns or charges a review twice.

```json
{
    "startUrls": ["https://www.booking.com/hotel/gb/park-plaza-westminster-bridge.html", "58824"],
    "maxReviewsPerPlace": 0,
    "languages": ["en", "fr"],
    "lastDays": 90
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. A review row:

```json
{
    "type": "review",
    "source": "booking",
    "placeId": "58824",
    "placeName": "Hotel Le Six",
    "reviewId": "83114b2385e2b5bf",
    "rating": 9.0,
    "ratingScale": 10,
    "title": "Quality hotel, perfectly located to visit Paris",
    "positiveText": "The location, a quiet area with plenty of small restaurants. Very comfortable bed, varied breakfast.",
    "negativeText": "Nothing",
    "language": "fr",
    "publishedAt": "2026-08-15T19:37:19Z",
    "checkinDate": "2026-08-10",
    "checkoutDate": "2026-08-15",
    "nights": 5,
    "travelerType": "COUPLES",
    "roomType": "Classic Double Room",
    "reviewerName": "Claire",
    "reviewerCountryCode": "FR",
    "ownerResponse": "Dear Claire, thank you so much for taking the time to share your feedback..."
}
```

### Tips

- Pipelines that run often on the same properties: pass hotel ids, or keep the URLs, the id lookup is cached after the first run.
- For monitoring, use **New reviews only** with a daily or weekly schedule.
- To call it from code, use the **API** tab or the Apify client:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("alexmorain/booking-reviews-scraper").call(run_input={
    "startUrls": ["https://www.booking.com/hotel/fr/le-six.html"],
    "maxReviewsPerPlace": 0,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["rating"], row["positiveText"])
```

### FAQ, disclaimers and support

#### Why do I get fewer reviews than the total on the property page?

Booking.com shows reviews from the last 36 months only, and the actor returns what Booking shows. Language and traveller type filters also reduce the count.

#### What if a URL fails?

A URL that redirects to a city page (a closed property) is reported in the log and skipped; the other URLs carry on. If Booking's bot check refuses the id lookup, pasting the numeric hotel id always works.

#### Is it legal to scrape Booking.com reviews?

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.

Something not working, or a field you need? Open an issue in the **Issues** tab, answers come fast. The same team publishes [Tripadvisor Reviews Scraper](https://apify.com/alexmorain/tripadvisor-reviews-scraper) and [Agoda Reviews Scraper](https://apify.com/alexmorain/agoda-reviews-scraper) with the same output columns.

# Actor input Schema

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

Booking.com property pages, one per line, such as <code>https://www.booking.com/hotel/fr/le-six.html</code>. Query strings and language suffixes are fine. A numeric hotel id such as <code>58824</code> also works and is the fastest input: the actor then skips the page lookup.

## `maxReviewsPerPlace` (type: `integer`):

Newest first. <b>0 = every review.</b> Each review is one charged result, so this is also your cost cap per URL.

## `lastDays` (type: `integer`):

Rolling window, handy for scheduled runs. Leave empty for the full history.

## `publishedAfter` (type: `string`):

Fixed start date (YYYY-MM-DD). If both this and the window are set, the later date wins.

## `languages` (type: `array`):

Language codes such as en, fr, de, es, it, nl, pt. Empty = all languages (recommended: a review in another language is still a review of the place).

## `travelerTypes` (type: `array`):

Only reviews from these traveller types, filtered by the site itself. Empty = all.

## `reviewMode` (type: `string`):

<b>New reviews only</b> remembers, per URL, which reviews it already delivered and returns only the new ones on the next run. Already delivered reviews are not charged again. Schedule it daily or weekly for monitoring.

## `registryKey` (type: `string`):

Name your monitoring memory to run several independent watches on the same URL (one per client, say). Empty = one memory per URL and filter set.

## `webhookUrl` (type: `string`):

Receives a JSON summary when the run ends (reviews, places, status, dataset id). Works with Slack, Make, Zapier, n8n.

## `includePlaceSummary` (type: `boolean`):

One extra row per URL with the place name, score and review count (charged as a place).

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

Apify datacenter proxy is enough and included. No residential proxy needed.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.booking.com/hotel/fr/le-six.html"
  ],
  "maxReviewsPerPlace": 20,
  "reviewMode": "all",
  "includePlaceSummary": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

One row per review

## `places` (type: `string`):

One summary row per page URL

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

Every row with all fields

# 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 = {
    "startUrls": [
        "https://www.booking.com/hotel/fr/le-six.html"
    ],
    "maxReviewsPerPlace": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/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 = {
    "startUrls": ["https://www.booking.com/hotel/fr/le-six.html"],
    "maxReviewsPerPlace": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/booking-reviews-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 '{
  "startUrls": [
    "https://www.booking.com/hotel/fr/le-six.html"
  ],
  "maxReviewsPerPlace": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call alexmorain/booking-reviews-scraper --silent --output-dataset

```

## MCP server setup

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