# FAST Booking.com Scraper \[$0.90💰] | Reviews Scale (`ahmed_jasarevic/fast-booking-scraper`) Actor

Scrape Booking.com hotel reviews at scale — fast GraphQL-based extraction with parallel requests. Extract ratings, comments and sentiment data for hospitality analytics.

- **URL**: https://apify.com/ahmed\_jasarevic/fast-booking-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 4 total users, 0 monthly users, 70.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 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.
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?

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

## FAST Booking.com Scraper

Extract hotel reviews, ratings, and data from any Booking.com property at scale — starting at just $0.90 per 1,000 results. This fast Booking.com scraper handles pagination, proxies, and anti-bot protection so you can focus on analysis, not infrastructure.

### Use Cases

- **Hotel Sentiment Analysis** — Aggregate thousands of guest reviews to identify sentiment trends, common complaints, and praised amenities across properties.
- **Competitor Benchmarking** — Compare ratings, review volume, and guest feedback across competing hotels in the same market or chain.
- **Bulk Review Extraction** — Pull complete review histories for academic research, investment due diligence, or hospitality consulting.
- **Market Research** — Map guest satisfaction patterns across destinations, hotel tiers, and seasons to inform pricing and positioning.
- **Review Monitoring** — Track new reviews over time to detect quality shifts, reputation crises, or service improvements.
- **Revenue Intelligence** — Correlate review trends with pricing and occupancy signals to build demand forecasting models.

### How It Works

1. **Input a Booking.com hotel URL** — Point the scraper to any property page.
2. **Configure depth and concurrency** — Set `maxPages` to control how many review pages to crawl and `concurrency` for parallel requests.
3. **Run the Actor** — The scraper navigates review pages, extracts structured data (reviewer name, date, score, title, body, stay type), handles pagination, and respects rate limits.
4. **Get your dataset** — Results are returned as clean JSON rows in an Apify dataset, ready for download, API access, or pipeline integration.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `startUrl` | `string` | *required* | Single Booking.com hotel URL (e.g. `https://www.booking.com/hotel/us/example.html`) |
| `maxPages` | `integer` | `10` | Maximum number of review pages to scrape per run |
| `concurrency` | `integer` | `5` | Number of parallel browser tabs for faster extraction |
| `useSystemChrome` | `boolean` | `false` | Use the system-installed Chrome instead of bundled Chromium |
| `headless` | `boolean` | `false` | Run browser in headless mode (no visible window) |
| `proxy` | `object` | — | Proxy configuration for IP rotation and geo-targeting |

### Output

Each row in the dataset contains:

| Field | Description |
|-------|-------------|
| `hotelName` | Name of the property |
| `hotelUrl` | Canonical Booking.com URL |
| `reviewerName` | Guest name (or pseudonym) |
| `reviewDate` | Date of the review |
| `rating` | Numerical score (e.g. 8.5) |
| `reviewTitle` | Headline of the review |
| `reviewBody` | Full review text |
| `stayType` | Room type or travel purpose if available |
| `scrapedAt` | Timestamp of extraction |

### Example

#### Input

```json
{
  "startUrl": "https://www.booking.com/hotel/us/example-property.html",
  "maxPages": 5,
  "concurrency": 3,
  "headless": true
}
```

#### Output (first 2 rows)

```json
[
  {
    "hotelName": "Example Grand Hotel",
    "hotelUrl": "https://www.booking.com/hotel/us/example-property.html",
    "reviewerName": "Sarah M.",
    "reviewDate": "2026-07-15",
    "rating": 9.2,
    "reviewTitle": "Exceptional stay, will return",
    "reviewBody": "Everything from check-in to checkout was seamless. The staff remembered our names...",
    "stayType": "Couple trip",
    "scrapedAt": "2026-08-30T14:22:01Z"
  },
  {
    "hotelName": "Example Grand Hotel",
    "hotelUrl": "https://www.booking.com/hotel/us/example-property.html",
    "reviewerName": "James K.",
    "reviewDate": "2026-07-10",
    "rating": 7.8,
    "reviewTitle": "Good but room for improvement",
    "reviewBody": "Location is unbeatable. Breakfast was crowded and the gym equipment needs updating...",
    "stayType": "Business trip",
    "scrapedAt": "2026-08-30T14:22:01Z"
  }
]
```

### Integrations

- **Google Sheets / Excel** — Export dataset via API or download as CSV for spreadsheet analysis.
- **Snowflake / BigQuery** — Push dataset rows into your data warehouse for SQL-based analytics.
- **Zapier / Make** — Trigger workflows on new dataset items (e.g. alert when average rating drops).
- **Python / Node.js** — Use the Apify Client to pull results directly into your scripts.
- **Slack / Email** — Set up notifications for run completion or anomaly detection.
- **LLM Pipelines** — Feed review text into GPT/Claude for theme extraction, summarization, or classification.

### Related Actors

- [Booking.com Review Scraper](https://apify.com/booking-review-scraper) — Dedicated review-focused extractor with sentiment tagging.
- [Booking.com Hotel Details Scraper](https://apify.com/booking-hotel-details) — Extract pricing, amenities, and property metadata.
- [Booking.com Search Scraper](https://apify.com/booking-search) — Crawl search results to discover hotels by destination and dates.

### FAQ

**How many reviews can I scrape per run?**
Depends on `maxPages`. Each page typically contains 10-25 reviews. With `maxPages: 10`, expect 100-250 reviews per hotel.

**Does this work with JavaScript-rendered content?**
Yes. The Actor uses a real browser engine, so all dynamically loaded reviews and metadata are captured.

**Can I scrape multiple hotels in one run?**
This Actor is optimized for single-URL input. For multi-hotel crawling, run multiple instances in parallel or use a scheduling orchestration layer.

**Is a proxy required?**
No, but recommended for high-volume or repeated scraping. Configure via the `proxy` input field.

**What Booking.com domains are supported?**
All Booking.com country domains (.com, .co.uk, .de, .fr, etc.) are supported.

**Can I use this for pricing data?**
This Actor focuses on reviews. For pricing and availability, see our Booking.com hotel details scraper.

### SEO Keywords

Booking.com scraper, fast hotel scraper, Booking.com reviews bulk, hotel review extraction scale, Booking.com data extraction, hotel sentiment bulk, Booking.com API alternative, hospitality data pipeline, hotel review aggregation, Booking.com bulk scraping, hotel competitive intelligence, review data at scale, travel data extraction, hotel analytics platform, Booking.com hotel data, hotel guest review scraper, Booking.com crawl, hotel reputation monitoring

### For AI Agents

This Actor is designed for programmatic use by AI agents and automated pipelines. Key considerations:

- **Deterministic input** — Pass `startUrl` as a fully qualified Booking.com property URL. Avoid ambiguous or malformed URLs.
- **Structured output** — Dataset rows follow a consistent schema, making them easy to parse and route.
- **Pipeline-friendly** — Use `waitSecs: 0` for fire-and-forget runs, then poll via `get-actor-run` and fetch results with `get-dataset-items`.
- **Cost control** — Set `maxPages` explicitly to cap extraction volume and cost per run.
- **Retry logic** — If a run fails (timeout, blocked), reduce `concurrency` or enable proxy rotation before retrying.

### Legal Disclaimer

This Actor extracts publicly available review data from Booking.com. It does not bypass authentication, access private user accounts, or circumvent access controls. Users are responsible for ensuring their use complies with Booking.com's Terms of Service and applicable data protection regulations (GDPR, CCPA, etc.). Scraped data should not be republished in ways that violate platform policies or intellectual property rights.

# Actor input Schema

## `startUrl` (type: `string`):

Full Booking hotel URL (e.g. https://www.booking.com/hotel/ba/courtyard-by-marriott-sarajevo.en-gb.html). IMPORTANT: if the hotel is closed or delisted on Booking.com, the page redirects to search results and NO reviews can be scraped - first verify the URL opens in your own browser.

## `maxPages` (type: `integer`):

Maximum number of review pages to fetch (10 reviews per page). Fetched via Booking's own GraphQL API - fast, no UI clicking.

## `concurrency` (type: `integer`):

Number of parallel GraphQL page requests. Higher = faster but more likely to hit rate limits. 3-8 recommended.

## `useSystemChrome` (type: `boolean`):

Launch the installed system Chrome instead of bundled Chromium. Recommended - Booking's WAF challenge only resolves in a headed browser.

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

Run browser in headless mode. NOTE: Booking's AWS WAF challenge does NOT resolve in headless Chromium - keep this disabled (false) for production.

## `proxy` (type: `object`):

Use Apify Proxy or custom proxies. IMPORTANT: Booking.com blocks datacenter IPs and redirects hotel pages to search results - select the RESIDENTIAL group, or enter custom residential/mobile proxy URLs.

## Actor input object example

```json
{
  "startUrl": "https://www.booking.com/hotel/ba/courtyard-by-marriott-sarajevo.en-gb.html",
  "maxPages": 10,
  "concurrency": 5,
  "useSystemChrome": true,
  "headless": false,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/fast-booking-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 = { "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    } }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/fast-booking-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 '{
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call ahmed_jasarevic/fast-booking-scraper --silent --output-dataset

```

## MCP server setup

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