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

\[💰 $1.5 / 1K] Extract hotel and accommodation listings from Booking.com — prices, ratings, addresses, amenities, photos, and per-room availability. Filter by stars, guest score, price, and property type across any destination worldwide.

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

## Pricing

from $1.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.

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 Scraper

Extract hotel and accommodation data from **Booking.com** at scale — names, prices, ratings, addresses, photos, amenities, and per-room availability — without writing any code. Search by destination keyword or paste Booking.com URLs directly. Get back clean, structured JSON ready for spreadsheets, dashboards, and downstream automations.

### Why This Scraper?

- **Pay only per result** — flat $1.50 per 1,000 hotels, no surprises.
- **No compute charges** — you only pay per result returned.
- **Every Booking.com search field exposed** — destination, dates, guests, rooms, property type, stars, guest score, price range, currency, language, and sort order.
- **Up to ~1,000 results per query** — Booking caps each search at roughly 1,000 hotels; this actor reaches that ceiling reliably.
- **Accurate per-night pricing** — both total stay cost and average per-night cost in your chosen currency.
- **Optional full hotel detail enrichment** — turn on `Include Room Details` to get amenities, room types, bed configurations, occupancy, gallery photos, lat/lng, and the complete address for each property.
- **Direct URL support** — paste any Booking.com search or hotel URL and the actor auto-detects the page type.
- **Datacenter proxy infrastructure included** — handled automatically; no proxy setup required from you.
- **14 supported languages, 19 currencies** — get review snippets and prices in the locale your users care about.

### Use Cases

**Travel & Booking Aggregators**
- Build OTA or meta-search comparison tools across hundreds of destinations.
- Refresh a curated hotel catalog daily with current prices and availability.
- Power "best deal" alerts when prices drop below a threshold.

**Market Research & Hospitality Analytics**
- Track average nightly rates by city, season, and star tier.
- Benchmark hotel inventory and pricing across competing destinations.
- Analyze guest score distributions to identify undervalued or overhyped properties.

**Competitive Pricing & Revenue Management**
- Monitor competitor pricing in real time for your own property.
- Detect rate parity issues across distribution channels.
- Identify when competitors are running discounts or premium pricing.

**Lead Generation for Hospitality SaaS**
- Build outreach lists of independent hotels, B&Bs, and guest houses by region.
- Identify properties with low review scores — prime targets for reputation-management products.
- Source unclaimed-looking listings for channel-management upsell.

**Travel Content & Editorial**
- Generate "Top 25 hotels in Lisbon" lists from live data.
- Power "best of" travel guides with current ratings, prices, and photos.
- Enrich travel blog posts with up-to-date hotel imagery and amenity lists.

**Real Estate & Short-Term Rental Intelligence**
- Map vacation-rental supply across cities to inform investment decisions.
- Compare apartment vs hotel pricing to evaluate STR market entry.
- Track villa and resort availability in seasonal markets.

### Getting Started

#### 1. Minimal — just a destination and dates

The fastest way to start. Default sort is "Top picks", default currency is USD, default language is English (UK), and you'll get up to 100 results.

```json
{
    "search": "hotels in Paris",
    "checkIn": "2026-06-15",
    "checkOut": "2026-06-17"
}
````

#### 2. Filtered — narrow by stars, score, and price

Find 4 and 5-star apartments and villas in Lisbon under EUR 200 per night with at least an 8.0 guest score.

```json
{
    "search": "Lisbon",
    "checkIn": "2026-07-10",
    "checkOut": "2026-07-15",
    "adults": 2,
    "propertyType": ["apartments", "villas"],
    "starsCountFilter": ["4", "5"],
    "minScore": "8",
    "priceMin": 80,
    "priceMax": 200,
    "currency": "EUR",
    "sortBy": "review_score",
    "maxResults": 100
}
```

#### 3. Direct Booking.com URLs

Paste any Booking.com search URL or hotel page URL. The actor detects the page type automatically and pulls the right data. Search URLs return the full result list; hotel URLs return a single enriched record.

```json
{
    "startUrls": [
        "https://www.booking.com/searchresults.en-gb.html?ss=Tokyo&checkin=2026-09-01&checkout=2026-09-04",
        "https://www.booking.com/hotel/fr/scarlett.en-gb.html"
    ],
    "currency": "USD"
}
```

#### 4. Full hotel detail enrichment with family rooms

Turn on `Include Room Details` to enrich every hotel with amenities, room types, bed configurations, lat/lng, and the complete gallery. When booking with children, list each child's age in `childrenAges` so Booking can price family rooms correctly.

```json
{
    "search": "Bali resorts",
    "checkIn": "2026-10-05",
    "checkOut": "2026-10-12",
    "adults": 2,
    "children": 2,
    "childrenAges": [5, 8],
    "rooms": 1,
    "propertyType": ["resorts"],
    "minScore": "9",
    "currency": "USD",
    "language": "en-us",
    "maxResults": 50,
    "includeRoomDetails": true
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `search` | string | `hotels in Paris` | City, region, country, or hotel name to search for on Booking.com. |
| `startUrls` | string\[] | `[]` | Paste Booking.com URLs to scrape — search-result pages or individual hotel pages. The actor auto-detects the page type. When provided, this overrides the destination. |

#### Dates & Guests

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `checkIn` | string (YYYY-MM-DD) | | Check-in date. Required to fetch live prices and room availability — leave empty for catalog data only. |
| `checkOut` | string (YYYY-MM-DD) | | Check-out date. Must be after the check-in date. |
| `adults` | integer | `2` | Number of adult guests (Booking considers age 13+ an adult). Range 1–30. |
| `children` | integer | `0` | Number of child guests (Booking considers ages 0–12 as children). Range 0–12. |
| `childrenAges` | integer\[] | `[]` | Age of each child (0–17). Required when `children > 0` — Booking prices family rooms based on these ages. Example: `[5, 8]` for two children aged 5 and 8. |
| `rooms` | integer | `1` | Number of rooms required. Range 1–30. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `propertyType` | string\[] | `[]` | Multi-select property types. Options: **Hotels**, **Apartments**, **Hostels**, **Bed & Breakfasts**, **Guest Houses**, **Resorts**, **Villas**, **Vacation Homes**. Empty = include all. |
| `starsCountFilter` | string\[] | `[]` | Multi-select official star ratings. Options: **1 star**, **2 stars**, **3 stars**, **4 stars**, **5 stars**. Empty = any number of stars. |
| `minScore` | string | | Minimum guest review score. Booking exposes four buckets: **6+ Pleasant**, **7+ Good**, **8+ Very Good**, **9+ Superb**. |
| `priceMin` | integer | | Minimum nightly price in the chosen currency. Leave empty for no minimum. |
| `priceMax` | integer | | Maximum nightly price in the chosen currency. Leave empty for no maximum. |
| `sortBy` | string | `popularity` | Result ranking. Options: **Top picks (popularity)**, **Price (lowest first)**, **Price (highest first)**, **Stars (highest first)**, **Distance from center**, **Top reviewed**. |

#### Localization

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `currency` | string | `USD` | Currency code for prices. Options: US Dollar, Euro, British Pound, Canadian Dollar, Australian Dollar, Japanese Yen, Chinese Yuan, Swiss Franc, Swedish Krona, Norwegian Krone, Danish Krone, Polish Złoty, UAE Dirham, Mexican Peso, Brazilian Real, Indian Rupee, Singapore Dollar, South African Rand, Turkish Lira. |
| `language` | string | `en-gb` | Booking.com site language. Options: English (UK), English (US), German, French, Spanish, Italian, Dutch, Portuguese, Polish, Russian, Japanese, Korean, Chinese, Arabic. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum hotels to return per search. Set to `0` for all available. Booking caps each query at about 1,000 — to get more, narrow your filters or split into smaller queries. |
| `includeRoomDetails` | boolean | `false` | Fetch per-hotel room offerings, full amenity lists, gallery photos, lat/lng, and the complete address for every result. Slows runs significantly and roughly doubles cost — enable only when you need amenities, room layouts, or coordinates. |

### Output

Every record includes the same set of structured fields. With `includeRoomDetails` on, each hotel is enriched with the full amenity list, room types, gallery, lat/lng, and complete address.

#### Example

```json
{
    "url": "https://www.booking.com/hotel/fr/scarlett.en-gb.html",
    "name": "Hotel Scarlett",
    "type": "Hotel",
    "description": "Hotel Scarlett is a charming 3-star hotel located in the heart of the 10th arrondissement, just a 5-minute walk from Gare du Nord and Gare de l'Est.",
    "stars": 3,
    "rating": 8.4,
    "ratingLabel": "Very Good",
    "reviewsCount": 1842,
    "price": {
        "amount": 312.0,
        "currency": "EUR",
        "perNight": 156.0
    },
    "checkIn": "2026-06-15",
    "checkOut": "2026-06-17",
    "breakfast": "Continental",
    "address": {
        "street": "39 Rue des Petites Ecuries",
        "postalCode": "75010",
        "city": "Paris",
        "region": "Île-de-France",
        "country": "France",
        "countryCode": "fr",
        "full": "39 Rue des Petites Ecuries, 75010 Paris, France"
    },
    "location": {
        "lat": 48.8742,
        "lng": 2.3531
    },
    "images": [
        "https://cf.bstatic.com/xdata/images/hotel/max1024x768/...",
        "https://cf.bstatic.com/xdata/images/hotel/max1024x768/..."
    ],
    "amenities": [
        "Free WiFi",
        "24-hour front desk",
        "Air conditioning",
        "Family rooms",
        "Non-smoking rooms",
        "Lift",
        "Daily housekeeping"
    ],
    "rooms": [
        {
            "available": true,
            "roomType": "Standard Double Room",
            "bedType": "1 double bed",
            "persons": 2,
            "price": null,
            "features": ["Free WiFi", "Private bathroom", "Air conditioning"]
        },
        {
            "available": true,
            "roomType": "Superior Twin Room",
            "bedType": "2 single beds",
            "persons": 2,
            "price": null,
            "features": ["Free WiFi", "City view", "Air conditioning"]
        }
    ],
    "bookingUrl": "https://www.booking.com/hotel/fr/scarlett.en-gb.html?aid=304142&checkin=2026-06-15&checkout=2026-06-17&group_adults=2&no_rooms=1&group_children=0",
    "scrapedAt": "2026-04-25T14:32:11+00:00"
}
```

#### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Canonical Booking.com page URL for the hotel. |
| `name` | string | Hotel or property name. |
| `type` | string | Accommodation type (Hotel, Apartment, Hostel, Bed & Breakfast, Villa, Resort, Guest House, Vacation Home, etc.). |
| `description` | string | Property description from Booking.com. Populated when `includeRoomDetails` is on, or when extracting from a hotel URL directly. |
| `stars` | number | Official star rating (1–5). `null` for properties using Booking's quality rating instead of stars. |
| `rating` | number | Booking.com guest review score (0–10). `null` for unrated properties. |
| `ratingLabel` | string | Human-readable rating label (e.g. "Superb", "Very Good", "Good"). |
| `reviewsCount` | number | Total number of guest reviews. |
| `price` | object | `{ amount, currency, perNight }` — total stay price, currency code, and average per-night price. `null` when dates are not provided. |
| `checkIn` | string | Check-in date echoed back (YYYY-MM-DD). |
| `checkOut` | string | Check-out date echoed back (YYYY-MM-DD). |
| `breakfast` | string | Breakfast offering when listed (e.g. "Continental", "Buffet"). |
| `address` | object | `{ street, postalCode, city, region, country, countryCode, full }` — populated to varying depth depending on enrichment mode. |
| `location` | object | `{ lat, lng }` — GPS coordinates. Populated when `includeRoomDetails` is on. |
| `images` | string\[] | Photo URLs. Search results return a single thumbnail; with detail enrichment you get the full gallery. |
| `amenities` | string\[] | Property-level amenities (Free WiFi, Pool, Gym, Pet-friendly, etc.). Populated when `includeRoomDetails` is on. |
| `rooms` | object\[] | Per-room offerings: `{ available, roomType, bedType, persons, price, features }`. Populated when `includeRoomDetails` is on. |
| `bookingUrl` | string | Direct booking link with your dates and guest counts pre-filled. |
| `scrapedAt` | string | ISO 8601 UTC timestamp of when the record was extracted. |

### Tips for Best Results

- **Use destinations Booking.com actually serves.** City names, regions, country names, and well-known hotel names work best. Spelling matters — "Phuket" returns thousands; "Phukkett" returns nothing.
- **Always provide check-in / check-out dates** if you want pricing and room availability. Without dates, you'll still get hotel info, but `price` will be `null` and `rooms` will be empty.
- **The chosen language affects review snippets and descriptions.** For US English content, set `language` to `en-us`; for German listings, use `de`.
- **Booking caps every search at about 1,000 results.** To get more, narrow your filters (one star tier, one property type, a tighter price band) or split a wide query into several smaller queries — for example, search city by city instead of "hotels in Europe".
- **Guest scores come in four buckets only.** Booking exposes 6+, 7+, 8+, and 9+. A score of 8.5 will return the same set as 8.
- **Sort by Top reviewed for quality lists.** This puts the highest-rated properties first regardless of price.
- **Sort by Price (lowest first) for budget research.** Combine with `priceMax` to cap the dataset to a specific budget tier.
- **Leave `includeRoomDetails` off for catalog-style runs.** Names, prices, stars, and ratings come back fast (default). Turn it on only when you need amenity lists, room layouts, gallery photos, or lat/lng — those add roughly 5–10 seconds per hotel and double the run cost.

### Pricing

**$1.50 per 1,000 results.**

No compute charges — you only pay per result returned.

| Results | Cost |
|---------|------|
| 100 | $0.15 |
| 1,000 | $1.50 |
| 10,000 | $15.00 |

### 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 on new results
- **Webhooks** — Custom API integrations
- **Apify API** — Full programmatic access

### Frequently Asked Questions

**Do I need a Booking.com account to use this actor?**
No. The actor extracts publicly visible listings; no account or login is required.

**Can I get more than 1,000 results for a single destination?**
Booking.com itself caps each search at about 1,000 results. To collect more, split your search into smaller queries — for example by neighborhood, by star tier, or by price band — and combine the datasets afterwards. Each narrower query is independent and can also return up to ~1,000 results.

**How does pagination work?**
The actor paginates automatically up to your `maxResults` cap or Booking's 1,000-result hard cap, whichever comes first. You don't need to set page numbers or offsets manually.

**What happens if my search returns zero hotels?**
The actor finishes successfully with an empty dataset and a clear status message suggesting how to widen your filters (lower the price range, drop the star filter, change language, or pick a more popular destination).

**Are prices live or cached?**
Prices are pulled from Booking.com at the moment the actor runs. They reflect the cheapest available offer for your dates, guest count, and room count — exactly as you'd see them on Booking.com.

**Why are some `stars` values `null`?**
Some properties — particularly apartments, vacation homes, and guest houses — use Booking.com's internal quality rating instead of official government-issued stars. The actor only emits a number when Booking confirms it as an official star rating; otherwise `stars` is `null` (the property's `type` field still tells you what kind of accommodation it is).

**Do I need to set up proxies?**
No. Datacenter proxy infrastructure is included automatically. You don't need to configure or pay for proxies separately.

### Legal & Ethical Use

This actor is designed for legitimate market research, travel content creation, business intelligence, and comparison shopping. It collects only publicly visible information from Booking.com search and listing pages. Users are responsible for complying with applicable laws and Booking.com's Terms of Service. Do not use the data to build replica booking platforms, generate spam, or for any illegal purpose.

# Actor input Schema

## `search` (type: `string`):

City, region, country, or hotel name to search for on Booking.com (e.g. 'Paris', 'New York', 'Bali resorts').

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

Paste Booking.com URLs to scrape — search-result pages or individual hotel pages. The actor auto-detects the page type. When provided, this overrides the destination above.

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

Check-in date in YYYY-MM-DD format. Required to fetch live prices and room availability — leave empty for catalog data only.

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

Check-out date in YYYY-MM-DD format. Must be after the check-in date.

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

Number of adult guests (Booking.com considers age 13 and up an adult).

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

Number of child guests (Booking.com considers ages 0-12 as children).

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

Age of each child guest (0-17). Required when 'Children' is greater than 0 — Booking.com prices family rooms based on these ages. Example: \[5, 8] for two children aged 5 and 8.

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

Number of rooms required.

## `propertyType` (type: `array`):

Restrict results to one or more types of accommodation. Multi-select. Empty = include all types.

## `starsCountFilter` (type: `array`):

Only include properties with these official star ratings. Multi-select. Empty = any number of stars.

## `minScore` (type: `string`):

Only include properties with at least this Booking.com guest review score. Booking exposes four review-score buckets — 6+, 7+, 8+, and 9+.

## `priceMin` (type: `integer`):

Minimum nightly price in the chosen currency. Leave empty for no minimum.

## `priceMax` (type: `integer`):

Maximum nightly price in the chosen currency. Leave empty for no maximum — high-denomination currencies (JPY, KRW, IDR, etc.) are handled correctly when this is empty.

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

How Booking.com should rank the results.

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

Currency code for prices.

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

Booking.com site language for result text.

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

Maximum hotels to return per search. Set to 0 for all available. Booking.com limits search results to about 1,000 per query — to get more, narrow your filters or split the search into smaller queries.

## `includeRoomDetails` (type: `boolean`):

Fetch per-hotel room offerings, full amenity lists, gallery photos, lat/lng, and the complete address for every result. Slows runs significantly and roughly doubles cost — enable only when you need amenities, room layouts, or coordinates. Leave off for fast catalog-only runs (names, prices, stars, ratings).

## Actor input object example

```json
{
  "search": "hotels in Paris",
  "startUrls": [],
  "adults": 2,
  "children": 0,
  "childrenAges": [],
  "rooms": 1,
  "propertyType": [],
  "starsCountFilter": [],
  "sortBy": "popularity",
  "currency": "USD",
  "language": "en-gb",
  "maxResults": 100,
  "includeRoomDetails": false
}
```

# Actor output Schema

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

Table of hotels with key fields: name, stars, rating, price, and address.

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

Full per-hotel rows including amenities, images, location, and rooms.

# 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 = {
    "search": "hotels in Paris",
    "startUrls": [],
    "adults": 2,
    "children": 0,
    "childrenAges": [],
    "rooms": 1,
    "propertyType": [],
    "starsCountFilter": [],
    "sortBy": "popularity",
    "currency": "USD",
    "language": "en-gb",
    "maxResults": 100,
    "includeRoomDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "search": "hotels in Paris",
    "startUrls": [],
    "adults": 2,
    "children": 0,
    "childrenAges": [],
    "rooms": 1,
    "propertyType": [],
    "starsCountFilter": [],
    "sortBy": "popularity",
    "currency": "USD",
    "language": "en-gb",
    "maxResults": 100,
    "includeRoomDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/booking-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 '{
  "search": "hotels in Paris",
  "startUrls": [],
  "adults": 2,
  "children": 0,
  "childrenAges": [],
  "rooms": 1,
  "propertyType": [],
  "starsCountFilter": [],
  "sortBy": "popularity",
  "currency": "USD",
  "language": "en-gb",
  "maxResults": 100,
  "includeRoomDetails": false
}' |
apify call solidcode/booking-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booking.com Scraper",
        "description": "[💰 $1.5 / 1K] Extract hotel and accommodation listings from Booking.com — prices, ratings, addresses, amenities, photos, and per-room availability. Filter by stars, guest score, price, and property type across any destination worldwide.",
        "version": "1.0",
        "x-build-id": "GiqiGbfeJZMXgRpHq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~booking-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-booking-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/solidcode~booking-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-booking-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/solidcode~booking-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-booking-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",
                "properties": {
                    "search": {
                        "title": "Destination",
                        "type": "string",
                        "description": "City, region, country, or hotel name to search for on Booking.com (e.g. 'Paris', 'New York', 'Bali resorts')."
                    },
                    "startUrls": {
                        "title": "Booking.com URLs",
                        "type": "array",
                        "description": "Paste Booking.com URLs to scrape — search-result pages or individual hotel pages. The actor auto-detects the page type. When provided, this overrides the destination above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "checkIn": {
                        "title": "Check-in Date",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format. Required to fetch live prices and room availability — leave empty for catalog data only."
                    },
                    "checkOut": {
                        "title": "Check-out Date",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format. Must be after the check-in date."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of adult guests (Booking.com considers age 13 and up an adult).",
                        "default": 2
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Number of child guests (Booking.com considers ages 0-12 as children).",
                        "default": 0
                    },
                    "childrenAges": {
                        "title": "Children Ages",
                        "type": "array",
                        "description": "Age of each child guest (0-17). Required when 'Children' is greater than 0 — Booking.com prices family rooms based on these ages. Example: [5, 8] for two children aged 5 and 8.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "rooms": {
                        "title": "Rooms",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of rooms required.",
                        "default": 1
                    },
                    "propertyType": {
                        "title": "Property Types",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Restrict results to one or more types of accommodation. Multi-select. Empty = include all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "hotels",
                                "apartments",
                                "hostels",
                                "bed_and_breakfasts",
                                "guest_houses",
                                "resorts",
                                "villas",
                                "vacation_homes"
                            ],
                            "enumTitles": [
                                "Hotels",
                                "Apartments",
                                "Hostels",
                                "Bed & Breakfasts",
                                "Guest Houses",
                                "Resorts",
                                "Villas",
                                "Vacation Homes"
                            ]
                        },
                        "default": []
                    },
                    "starsCountFilter": {
                        "title": "Hotel Stars",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include properties with these official star ratings. Multi-select. Empty = any number of stars.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 star",
                                "2 stars",
                                "3 stars",
                                "4 stars",
                                "5 stars"
                            ]
                        },
                        "default": []
                    },
                    "minScore": {
                        "title": "Minimum Guest Score",
                        "enum": [
                            "6",
                            "7",
                            "8",
                            "9"
                        ],
                        "type": "string",
                        "description": "Only include properties with at least this Booking.com guest review score. Booking exposes four review-score buckets — 6+, 7+, 8+, and 9+."
                    },
                    "priceMin": {
                        "title": "Minimum Price per Night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum nightly price in the chosen currency. Leave empty for no minimum."
                    },
                    "priceMax": {
                        "title": "Maximum Price per Night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum nightly price in the chosen currency. Leave empty for no maximum — high-denomination currencies (JPY, KRW, IDR, etc.) are handled correctly when this is empty."
                    },
                    "sortBy": {
                        "title": "Sort Order",
                        "enum": [
                            "popularity",
                            "price_low",
                            "price_high",
                            "stars",
                            "distance",
                            "review_score"
                        ],
                        "type": "string",
                        "description": "How Booking.com should rank the results.",
                        "default": "popularity"
                    },
                    "currency": {
                        "title": "Currency",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP",
                            "CAD",
                            "AUD",
                            "JPY",
                            "CNY",
                            "CHF",
                            "SEK",
                            "NOK",
                            "DKK",
                            "PLN",
                            "AED",
                            "MXN",
                            "BRL",
                            "INR",
                            "SGD",
                            "ZAR",
                            "TRY"
                        ],
                        "type": "string",
                        "description": "Currency code for prices.",
                        "default": "USD"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en-gb",
                            "en-us",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "pt",
                            "pl",
                            "ru",
                            "ja",
                            "ko",
                            "zh",
                            "ar"
                        ],
                        "type": "string",
                        "description": "Booking.com site language for result text.",
                        "default": "en-gb"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum hotels to return per search. Set to 0 for all available. Booking.com limits search results to about 1,000 per query — to get more, narrow your filters or split the search into smaller queries.",
                        "default": 100
                    },
                    "includeRoomDetails": {
                        "title": "Include Room Details",
                        "type": "boolean",
                        "description": "Fetch per-hotel room offerings, full amenity lists, gallery photos, lat/lng, and the complete address for every result. Slows runs significantly and roughly doubles cost — enable only when you need amenities, room layouts, or coordinates. Leave off for fast catalog-only runs (names, prices, stars, ratings).",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
