# Booking.com Reviews Scraper (`solidcode/booking-reviews-scraper`) Actor

\[💰 $1.3 / 1K] Extract guest reviews from any Booking.com property — full text, scores, languages, room types, stay dates, and partner replies. Pipe in URLs or pass the output of our Booking.com Scraper directly.

- **URL**: https://apify.com/solidcode/booking-reviews-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Travel, Developer tools, Automation
- **Stats:** 64 total users, 25 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 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/actors/running/actors-in-store.md#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 Reviews Scraper

Pull every guest review from any Booking.com property at scale — full review text, headlines, 1–10 guest scores, traveler segments, room types, stay dates, partner replies, and guest-uploaded photos — straight into a clean dataset, one review per row. Pipe in raw property URLs OR drop in the entire output of our [Booking.com Hotel Scraper](https://apify.com/SolidCode/booking-scraper) and start collecting reviews on the same run. Built for hospitality competitive-analysts, market-research firms, hotel-investment due-diligence teams, and SaaS reputation tools that need fresh, structured Booking.com review data without wrestling with rotating filters, multilingual pagination, and embedded reply threads.

### Why This Scraper?

- **$1.30 per 1,000 reviews — flat PPR.** No compute charges, no per-property surcharge, no enrichment upcharges. One row = one review = one charge.
- **Native pipe from the [Booking.com Hotel Scraper](https://apify.com/SolidCode/booking-scraper)** — paste the upstream actor's dataset rows directly into `startUrls`. Any object with a `url` key is auto-detected; every other field is ignored. No glue script, no manual URL extraction.
- **Five-axis filtering on Booking's native facets** — 5 sort orders (Most Relevant, Newest, Oldest, Score High-to-Low, Score Low-to-High), 6 non-overlapping score buckets (Wonderful 9–10, Good 7–8, Okay 5–6, Poor 3–4, Very Poor 1–2, plus All), 26 review languages, 6 traveler segments (Families, Couples, Solo, Groups of Friends, Business, plus All), and 5 review-season windows keyed on the date the review was posted (Mar–May, Jun–Aug, Sep–Nov, Dec–Feb, plus Any time of year).
- **30 fields per review row** — review headline, "Liked"/"Disliked" body, 1–10 guest score, helpful-vote count, language code, traveler segment, anonymous flag, guest display name, guest country (ISO-2 + display name), avatar URL, room-type ID + name, nights stayed, stay status, check-in / check-out month, hotel reply text, photo array (`{ id, urls.thumbnail, urls.large, kind }`), Booking review ID, and a deep-link `reviewUrl` anchored to the review on the property page.
- **26 review languages, regional variants included** — English, German, French, Spanish, Italian, Dutch, Portuguese, Polish, Russian, Japanese, Korean, Chinese, Arabic, Turkish, Swedish, Norwegian, Danish, Finnish, Czech, Hungarian, Romanian, Greek, Hebrew, Thai, Vietnamese, Indonesian. Picking Spanish also brings back Mexican and Latin-American Spanish, English also brings back US English, Portuguese also brings back Brazilian Portuguese — variants Booking's own language menu leaves out. Multi-select for cross-market sentiment work; leave empty to collect every language.
- **Partner reply capture, free** — toggle `Include Hotel Replies` on (default) and every row carries the property's official `partnerReplyText`. Critical for reputation-management SaaS measuring response rate, response speed, and tone across a portfolio.
- **Guest-uploaded photos in every row** — Booking exposes original-resolution `large` and `thumbnail` URLs; both come back as a `photos` array per review for hotel-amenity computer-vision pipelines.
- **Predictable cost ceiling per property** — `Max Reviews Per Property` defaults to 1,000 (worst case $1.30 per property), with `0` opting in to "all available". Booking mega-properties can carry 10,000+ reviews; the cap stops cost runaways before they happen.
- **Tolerant input parsing** — handles plain URL strings, bare `{ "url": "..." }` objects, and full upstream dataset rows with extra fields. Rows where `url` is missing or null are quietly skipped instead of crashing the run.

### Use Cases

**Hospitality Market Research**

- Benchmark guest sentiment across an entire city's 4-star inventory.
- Compare review-language mix to validate which markets a property is winning.
- Quantify month-over-month review velocity and average score for a competitor set.

**Reputation Management & Hotel SaaS**

- Power dashboards that surface fresh negative reviews to ops teams within hours.
- Audit a chain's partner-reply coverage — measure response rate, lag, and tone.
- Feed verbatim "Liked" and "Disliked" text into NLS / topic-modeling pipelines.

**Investment Due-Diligence**

- Pull 10 years of reviews on an acquisition target to validate brand health.
- Detect renovation impact: split scores by check-in date, before vs after a known refurbishment window.
- Surface the top recurring complaints driving sub-7 scores in a target portfolio.

**OTA & Meta-search Aggregation**

- Refresh reviews nightly across a curated catalog of 10,000+ hotels.
- Augment an in-house listings index with multilingual review snippets.
- Cross-check Booking review counts against TripAdvisor / Google for inventory parity.

**Trend & Sentiment Monitoring**

- Track sentiment by season — compare summer vs winter review tone in seasonal markets.
- Compare solo-traveler vs family vs business guest segments on the same property.
- Monitor a single hotel's score distribution week-over-week to flag service drift.

**Travel Editorial & Content**

- Generate "What guests really say about Le Meurice" articles from verified Booking text.
- Curate "Top 25 family-friendly hotels in Lisbon" lists from filtered review datasets.
- Pull guest photos to enrich hotel review write-ups with real-stay imagery.

### Getting Started

#### 1. Minimal — one property, all defaults

Returns up to 1,000 most-relevant reviews from a single property, every language, every traveler type, every score, every season. Hotel replies are included.

```json
{
    "startUrls": [
        { "url": "https://www.booking.com/hotel/fr/le-meurice.en-gb.html" }
    ]
}
```

#### 2. Mid — newest negative reviews only

Triage the 100 most recent low-scoring reviews to find emerging service issues. Useful for ops dashboards and reputation alerts.

```json
{
    "startUrls": [
        { "url": "https://www.booking.com/hotel/gb/the-savoy.en-gb.html" }
    ],
    "sortBy": "newest",
    "scoreFilter": "poor",
    "maxReviewsPerProperty": 100
}
```

#### 3. Advanced — pipe the Hotel Scraper output, then narrow by language and traveler

Run the [Booking.com Hotel Scraper](https://apify.com/SolidCode/booking-scraper) over a destination first, then drop its dataset rows straight into this actor's `startUrls`. The `url` key on each row is read; every other field (rating, price, address, etc.) is ignored. Below, only English-speaking solo-traveler reviews are collected, capped at 200 per property.

```json
{
    "startUrls": [
        { "url": "https://www.booking.com/hotel/gb/the-savoy.en-gb.html", "name": "The Savoy", "rating": 9.2 },
        { "url": "https://www.booking.com/hotel/fr/le-meurice.en-gb.html", "name": "Hotel Le Meurice", "rating": 9.0 },
        { "url": "https://www.booking.com/hotel/it/danieli.en-gb.html", "name": "Hotel Danieli", "rating": 8.9 }
    ],
    "languages": ["en"],
    "customerType": "solo",
    "maxReviewsPerProperty": 200,
    "includeReplies": true
}
```

### Input Reference

#### Property URLs

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | array | `[ "https://www.booking.com/hotel/fr/le-meurice.en-gb.html" ]` | Booking.com property URLs to scrape reviews from. Accepts plain URL strings, bare `{ "url": "..." }` objects, OR rows from another actor's dataset (any object with a `url` key — every other field is ignored). |

#### Pagination & Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxReviewsPerProperty` | integer | `1000` | Cap on reviews collected per property. Set to `0` to pull every available review (popular hotels can carry several thousand). Pricing is per review row, so this is your main cost lever. |

#### Sorting & Filtering

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | string | `relevant` | How Booking.com orders reviews before collection. Options: **Most Relevant**, **Newest first**, **Oldest first**, **Highest score first**, **Lowest score first**. **Most Relevant** is Booking.com's own ranking, centred on the property's overall guest rating, so a capped run clusters around that rating. Use **Newest first** or **Oldest first** for a representative cross-section (see Tips). |
| `scoreFilter` | string | `all` | Limit to one Booking score bucket. Guest scores are whole numbers 1–10, so the buckets never overlap. Options: **All**, **Wonderful (9–10)**, **Good (7–8)**, **Okay (5–6)**, **Poor (3–4)**, **Very poor (1–2)**. |
| `languages` | array | `[]` (all) | Multi-select review languages. Choose any subset of: English, German, French, Spanish, Italian, Dutch, Portuguese, Polish, Russian, Japanese, Korean, Chinese, Arabic, Turkish, Swedish, Norwegian, Danish, Finnish, Czech, Hungarian, Romanian, Greek, Hebrew, Thai, Vietnamese, Indonesian. Each choice also brings back its regional variants — see the `language` field in the output table. |
| `customerType` | string | `all` | Filter by traveler segment. Options: **All travelers**, **Families**, **Couples**, **Solo travelers**, **Groups of friends**, **Business travelers**. **Business travelers** filters on the purpose of the trip; the `customerType` column in the output reports the guest group instead, so those rows come back as `families` / `couples` / `solo` / `groups`. |
| `timeOfYear` | string | `all` | Filter by the season the review was **posted** in, not the season of the stay. Options: **Any time of year**, **March – May (spring)**, **June – August (summer)**, **September – November (fall)**, **December – February (winter)**. |

#### Output Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeReplies` | boolean | `true` | Attach the property's official reply text to each review when available. Adds `partnerReplyText` at no extra cost, plus the companion `partnerReplyDate` column that Booking.com currently leaves empty. |

### Output

One row per review, flat schema for clean dataset table display.

#### Example

```json
{
    "hotelUrl": "https://www.booking.com/hotel/fr/le-meurice.en-gb.html",
    "hotelId": 55361,
    "hotelName": "Hotel Le Meurice",
    "hotelCountryCode": "fr",
    "reviewId": "6340bcc03d6b080b",
    "reviewUrl": "https://www.booking.com/hotel/fr/le-meurice.en-gb.html#tab-reviews?review=6340bcc03d6b080b",
    "reviewDate": "2026-04-18T15:17:40Z",
    "title": "Excellent value for your money",
    "positiveText": "Location is great, the staff were extremely helpful and the room was spotless.",
    "negativeText": "There aren't any negatives for me staying here.",
    "score": 10,
    "language": "en",
    "helpfulVotesCount": 4,
    "isApproved": true,
    "customerType": "solo",
    "anonymous": false,
    "guestName": "Carollyn",
    "guestCountryCode": "us",
    "guestCountryName": "United States",
    "avatarUrl": "https://q-xx.bstatic.com/xdata/avatars/...",
    "roomTypeId": "5536114",
    "roomTypeName": "Standard Double Room",
    "numNights": 2,
    "stayStatus": "stayed",
    "checkInDate": "2026-04-12",
    "checkOutDate": "2026-04-14",
    "partnerReplyText": "Thank you for your wonderful review, Carollyn — we look forward to welcoming you back to Le Meurice.",
    "partnerReplyDate": null,
    "photos": [
        {
            "id": "12345678",
            "urls": {
                "thumbnail": "https://q-xx.bstatic.com/xdata/images/xphoto/square80/12345678.jpg",
                "large": "https://q-xx.bstatic.com/xdata/images/xphoto/max1280x900/12345678.jpg"
            },
            "kind": "guest"
        }
    ],
    "scrapedAt": "2026-05-01T19:16:14Z"
}
```

#### Hotel Context Fields

| Field | Type | Description |
|-------|------|-------------|
| `hotelUrl` | string | The property URL exactly as you submitted it, so rows join straight back onto your input list. |
| `hotelId` | integer | Booking.com internal property ID. |
| `hotelName` | string | Hotel display name. |
| `hotelCountryCode` | string | ISO-2 country code (e.g. `fr`, `gb`, `it`). |

#### Core Review Fields

| Field | Type | Description |
|-------|------|-------------|
| `reviewId` | string | Booking-side review identifier. Stable across runs. |
| `reviewUrl` | string | Deep-link that opens this review on the property's own page. When you submit an older Booking.com address for a property, the link points at the page that address now leads to. |
| `reviewDate` | string (ISO 8601) | When the review was submitted to Booking. |
| `title` | string | Review headline written by the guest. |
| `positiveText` | string | "Liked" body. |
| `negativeText` | string | "Disliked" body. |
| `score` | integer (1–10) | Reviewer's overall score for the stay. Booking asks each guest for a single whole-number rating from 1 to 10, so this is never a decimal. The decimal scores shown on Booking (for example 8.7) are the property average across all reviews, not one guest's score. |
| `language` | string | Two-letter code for the language the review was written in (`en`, `de`, `fr`, ...). Booking marks regional variants with its own codes instead: `xu` US English, `xb` Brazilian Portuguese, `xa` Latin-American Spanish, `xm` Mexican Spanish, `xt` Traditional Chinese. These arrive with the parent language you filtered on, so a run filtered to English returns both `en` and `xu` rows. |
| `helpfulVotesCount` | integer | Number of "Helpful" upvotes. |
| `isApproved` | boolean | Booking-side moderation flag. |

#### Guest Fields

| Field | Type | Description |
|-------|------|-------------|
| `customerType` | string | Guest group Booking recorded for the stay: `families`, `couples`, `solo`, or `groups`. This is a different question from the `customerType` **input** filter, which selects on trip purpose, so this column never reads `business`. |
| `anonymous` | boolean | Whether the guest chose to remain anonymous. |
| `guestName` | string | Display name (or `Anonymous` when `anonymous=true`). |
| `guestCountryCode` | string | Reviewer's home-country ISO-2 code. |
| `guestCountryName` | string | Reviewer's home-country display name. |
| `avatarUrl` | string | null | Reviewer avatar URL when public. |

#### Stay Fields

| Field | Type | Description |
|-------|------|-------------|
| `roomTypeId` | string | Booking room-type ID for the booked stay. |
| `roomTypeName` | string | Human-readable room type (e.g. "Deluxe Double Room"). |
| `numNights` | integer | Length of stay in nights. |
| `stayStatus` | string | `stayed`, `cancelled`, etc. (Booking taxonomy). |
| `checkInDate` | string (YYYY-MM-DD) | Date the guest checked in. |
| `checkOutDate` | string (YYYY-MM-DD) | Date the guest checked out. |

#### Hotel Reply, Photos & Metadata

| Field | Type | Description |
|-------|------|-------------|
| `partnerReplyText` | string | null | Hotel's official response to the review when present. `null` if no reply or `includeReplies=false`. |
| `partnerReplyDate` | string | null | Reply timestamp. Booking.com exposes the field but has left it empty on every review measured, so treat this column as reserved: it fills itself if Booking ever starts publishing reply dates. |
| `photos` | array of `{ id, urls: { thumbnail, large }, kind }` | Guest-uploaded photos. Empty array when none. |
| `scrapedAt` | string (ISO 8601) | UTC timestamp of extraction. |

### Tips for Best Results

- **Pipe the [Booking.com Hotel Scraper](https://apify.com/SolidCode/booking-scraper) output here directly.** Run a destination + filter search in the Hotel Scraper, then drop the output dataset URL straight into `startUrls` in this actor — every row's `url` is read automatically; everything else is ignored. No glue script needed for end-to-end "destination → reviews" pipelines.
- **Sort order decides which slice of the score range you get, so pick it before you cap.** Booking.com's "most relevant" ranking is centred on the property's own overall rating, which means a capped run keeps the reviews nearest that score and drops both ends. Measured at a 300-review cap: `relevant` returned just 3 of the 10 possible scores on Atlantis The Palm (8/9/10), Park Plaza Westminster Bridge (7/8/9) and Excalibur Las Vegas (7/8/9), with no review below 7 anywhere and no perfect 10 on the last two. `newest` on the same three properties at the same cap returned all 10 scores, including 20, 39 and 60 reviews below 7. Use `relevant` for the reviews Booking.com itself surfaces first, `newest` for score histograms, complaint mining and sentiment work, `score_asc` to triage the worst-rated reviews for a reputation dashboard, and a cap of 0 when you want the complete distribution.
- **For multi-language sentiment work, run separate jobs per language and join on `reviewId`.** This keeps each dataset narrowly scoped and avoids paying for languages you won't analyze. Group each language with its variants when you tally the results.
- **Cap `maxReviewsPerProperty` at 1,000 unless you genuinely need every review.** Mega-properties on Booking can carry 10,000+ reviews — at $1.30 per 1,000 that's $13 per property if uncapped. The default 1,000 keeps spend predictable.
- **Combine `scoreFilter=very_poor` with `customerType=business`** to surface the highest-impact complaints from corporate guests — these reviews often drive the biggest churn risk for hotel sales teams. The rows come back tagged with the guest group (`couples`, `solo`, and so on), because that column answers a different question than the filter does.
- **A whole-number `score` is correct, not a rounding error.** Booking collects one 1–10 rating per guest. Averaging `score` across a property gives you the decimal figure Booking displays on the listing.
- **Don't discard the `xu`, `xb`, `xa`, `xm` and `xt` rows.** They are Booking's codes for US English, Brazilian Portuguese, Latin-American Spanish, Mexican Spanish and Traditional Chinese. On a Las Vegas property, US English alone was 15,611 of 31,018 reviews, so a pipeline that keeps only `en` throws away most of its English data. Map them onto the parent language before you aggregate.
- **Measure reply coverage from `partnerReplyText`, not from a date.** Booking publishes the reply itself but not when it was written, so `partnerReplyDate` arrives empty; response-rate reporting works fine off the text, response-*speed* reporting does not.

### Pricing

**$1.30 per 1,000 reviews** — flat per-result price.

No compute charges — you only pay per review returned.

| Reviews | Cost |
|---------|------|
| 100 | $0.13 |
| 1,000 | $1.30 |
| 10,000 | $13.00 |
| 100,000 | $130.00 |

One dataset row = one review = one charge. `maxReviewsPerProperty` is a **per-property** cap, so a run over 20 property URLs at the default 1,000 can return 20,000 rows; set the cap to the number you actually want per hotel, and use the `scoreFilter` / `languages` / `customerType` / `timeOfYear` filters to narrow the volume before the run starts.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications when new reviews land
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access from any language

### Legal & Ethical Use

This actor is designed for legitimate market research, hospitality intelligence, reputation management, investment analysis, and travel content creation. It collects only publicly visible review content from Booking.com property pages. Users are responsible for complying with applicable laws — including data-protection regimes that govern personal information in guest names and avatars — and with Booking.com's Terms of Service. Do not use the data to harass individuals, build replica review platforms, generate spam, or for any unlawful purpose.

# Actor input Schema

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

Booking.com hotel page URLs to scrape reviews from. Paste raw URLs (e.g. 'https://www.booking.com/hotel/fr/le-meurice.en-gb.html') OR feed in the output dataset of our Booking.com Scraper directly — rows that contain a 'url' field will be picked up automatically. One review per dataset row.

## `maxReviewsPerProperty` (type: `integer`):

Cap on reviews collected per property. The cap applies to each property separately, so 10 property URLs at 1,000 can return 10,000 rows. Set to 0 for all available reviews — popular hotels can have several thousand. Pricing is per review row, so this is your main cost control.

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

How Booking.com should order reviews before we collect them. Affects which reviews you get first when 'Max Reviews Per Property' is set. 'Most relevant' is Booking.com's own ranking and it is centred on the property's overall guest rating, so a capped run returns reviews clustered around that rating and can leave out the very highest and very lowest scores completely. Measured at a 300-review cap: 'Most relevant' returned only 3 of the 10 possible scores on Atlantis The Palm (8, 9, 10), Park Plaza Westminster Bridge (7, 8, 9) and Excalibur Las Vegas (7, 8, 9), while 'Newest first' on the same three properties at the same cap returned all 10 scores. Choose 'Newest first' or 'Oldest first' when you need a representative cross-section for score histograms or sentiment analysis, or set the cap to 0 to collect every review.

## `scoreFilter` (type: `string`):

Only collect reviews in this Booking.com score bucket. Guests rate a stay with a whole number from 1 to 10, so the buckets do not overlap: Good returns 7s and 8s, Wonderful returns 9s and 10s. Leave on 'All' to collect every review.

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

Only collect reviews written in these languages. Multi-select. Empty = all languages. Regional variants come with the language you pick: English also returns US English, Portuguese also returns Brazilian Portuguese, Spanish also returns Latin-American and Mexican Spanish, and Chinese also returns Traditional Chinese. Those rows carry Booking.com's own variant code in the 'language' column ('xu', 'xb', 'xa', 'xm', 'xt') rather than the plain two-letter code.

## `customerType` (type: `string`):

Only collect reviews from this traveler segment, using Booking.com's own filter. 'All' returns every traveler type. Note that 'Business travelers' filters on the purpose of the trip, while the 'customerType' column on each row reports the guest group Booking.com recorded — families, couples, solo or groups. Business-trip reviews therefore come back labelled with a guest group, never with 'business'.

## `timeOfYear` (type: `string`):

Only collect reviews posted in this part of the year. Booking.com's seasonal filter keys on the date the review was written, not on the dates of the stay — guests usually post within a few weeks of checking out, so a summer window can include a stay that ended in late spring. Useful when comparing summer vs. winter feedback.

## `includeReplies` (type: `boolean`):

Include the property's official reply to each review when available. Adds 'partnerReplyText' to each row at no extra cost. The companion 'partnerReplyDate' column is read from the same reply record, but Booking.com leaves that timestamp empty on every review we have seen, so expect it to be blank.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.booking.com/hotel/fr/le-meurice.en-gb.html"
    }
  ],
  "maxReviewsPerProperty": 1000,
  "sortBy": "relevant",
  "scoreFilter": "all",
  "languages": [],
  "customerType": "all",
  "timeOfYear": "all",
  "includeReplies": true
}
```

# Actor output Schema

## `overview` (type: `string`):

Quick-scan table of reviews with hotel, score, date, and headline.

## `details` (type: `string`):

Full per-review rows including positive/negative text, traveler info, room, stay dates, photos, and partner reply.

# 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": [
        {
            "url": "https://www.booking.com/hotel/fr/le-meurice.en-gb.html"
        }
    ],
    "maxReviewsPerProperty": 1000,
    "sortBy": "relevant",
    "scoreFilter": "all",
    "languages": [],
    "customerType": "all",
    "timeOfYear": "all",
    "includeReplies": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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": [{ "url": "https://www.booking.com/hotel/fr/le-meurice.en-gb.html" }],
    "maxReviewsPerProperty": 1000,
    "sortBy": "relevant",
    "scoreFilter": "all",
    "languages": [],
    "customerType": "all",
    "timeOfYear": "all",
    "includeReplies": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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": [
    {
      "url": "https://www.booking.com/hotel/fr/le-meurice.en-gb.html"
    }
  ],
  "maxReviewsPerProperty": 1000,
  "sortBy": "relevant",
  "scoreFilter": "all",
  "languages": [],
  "customerType": "all",
  "timeOfYear": "all",
  "includeReplies": true
}' |
apify call solidcode/booking-reviews-scraper --silent --output-dataset

```

## MCP server setup

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