# Booking.com Scraper (Pay-Per-Event) (`prodiger/booking-scraper`) Actor

Scrape Booking.com hotel search results or direct hotel pages. Returns 22 fields per hotel including prices, ratings, reviews, location, address, and coordinates. Run-scoped dedupe by hotelId. Pay-per-event pricing — only pay for the hotels you actually scrape.

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

## Pricing

Pay per event

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.** Get prices, ratings, reviews, room types, photos, availability, address, and coordinates for any location worldwide. Pay-per-event pricing — only pay for the hotels you actually scrape.

### What does Booking.com Scraper do?

Booking.com Scraper extracts hotel and accommodation data from [Booking.com](https://www.booking.com) search results or directly from specific hotel pages. Enter a city or region (or paste direct hotel URLs), set your travel dates and guest count, and get structured data on prices, ratings, reviews, room types, and availability — exported as JSON, CSV, or Excel.

It uses a real browser (Playwright) and residential proxies to load search results, which means it handles Booking.com's AWS WAF anti-bot protection reliably. Pagination is automatic — the scraper walks result pages until your `maxResults` limit is reached.

This actor is a clean-room reimplementation in the spirit of `automation-lab/booking-scraper`, **at identical pay-per-event pricing**, with two practical improvements:

- **Run-scoped dedupe by `hotelId`.** Overlapping searches or sponsored-then-organic placements within a single run are pushed and charged exactly once.
- **Two extra output fields:** `address` (a clean street/area string from the property tile) and `coordinates` (`{ latitude, longitude }`).

### Who is it for?

Booking.com Scraper is built for data professionals, travel-industry analysts, and developers who need reliable access to Booking.com hotel data at scale — without a Booking.com API key or Affiliate Program approval.

- Revenue managers and hoteliers monitoring competitor pricing
- Travel agencies and OTAs building data feeds or price-comparison tools
- Data analysts and researchers studying hotel supply, pricing trends, and reviews
- Developers integrating accommodation data into apps, dashboards, or pipelines

### Use cases

- **Travel price monitoring** — track hotel prices over time to find the best booking window
- **Competitor analysis** — compare your property's pricing and review scores against nearby competitors
- **Market research** — analyze hotel supply, pricing tiers, and review distributions across cities or regions
- **Lead generation** — build lists of hotels with contact pages, locations, and ratings
- **Aggregator data feeds** — power a travel comparison site or internal dashboard with fresh Booking.com data

### Why use this scraper?

- **Handles anti-bot protection** — Playwright + residential proxies bypass Booking.com's AWS WAF where HTTP scrapers fail
- **22 data fields per hotel** — prices, review scores, star ratings, room types, cancellation policy, breakfast, photos, **address, coordinates**, and more
- **Automatic pagination** — walks all search result pages
- **Run-scoped dedupe** — overlapping searches never double-bill
- **Flexible filters** — dates, guests, rooms, price range, star rating, sort order, currency, language
- **Pay per result** — no monthly subscription, only pay for the hotels you scrape
- **Clean, flat output** — every field is a primitive type or simple object, ready for spreadsheets and databases

### How to scrape Booking.com hotels

#### Option A — search by location

1. Open the actor's Input tab
2. Enter a `locationQuery` — any city, region, or country (e.g., "London", "Paris, France", "Tokyo")
3. Optionally set `checkin` and `checkout` dates (default: tomorrow + 2 nights)
4. Adjust `adults`, `rooms`, `children` as needed
5. Set `maxResults` to control how many hotels to scrape
6. Click **Start**

Example input:

```json
{
    "locationQuery": "London",
    "checkin": "2026-06-01",
    "checkout": "2026-06-03",
    "adults": 2,
    "rooms": 1,
    "maxResults": 50,
    "sortBy": "popularity",
    "currency": "USD"
}
````

#### Option B — scrape specific hotels by direct URL

If you want data for one or more specific properties, paste their Booking.com URLs into the `startUrls` field. The scraper visits each property page and extracts all available data.

```json
{
    "startUrls": [
        { "url": "https://www.booking.com/hotel/gb/the-savoy.html" },
        { "url": "https://www.booking.com/hotel/gb/claridges.html" }
    ],
    "checkin": "2026-06-01",
    "checkout": "2026-06-03",
    "adults": 2
}
```

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | — | Direct Booking.com hotel page URLs to scrape. Either `startUrls` or `locationQuery` is required. |
| `locationQuery` | string | — | City, region, country, or hotel name to search. Required if no `startUrls` provided. |
| `checkin` | string | tomorrow | Check-in date in `YYYY-MM-DD` format. |
| `checkout` | string | checkin + 2 days | Check-out date in `YYYY-MM-DD` format. |
| `adults` | integer | 2 | Number of adult guests (1–30). |
| `rooms` | integer | 1 | Number of rooms (1–30). |
| `children` | integer | 0 | Number of children (0–10). |
| `maxResults` | integer | 100 | Maximum number of hotels to return (location search). 0 = unlimited (hard-capped at 1000). |
| `sortBy` | enum | `popularity` | Sort order: `popularity`, `price`, `bayesian_review_score`, `class`, `distance`. |
| `currency` | string | `USD` | Currency code for prices (USD, EUR, GBP, etc.). |
| `language` | string | `en-us` | Language code (`en-us`, `de`, `fr`, `es`, `it`, `ja`, `zh-cn`, etc.). |
| `minPrice` | integer | — | Minimum price per night filter. |
| `maxPrice` | integer | — | Maximum price per night filter. |
| `starsFilter` | string\[] | — | Filter by star rating (e.g., `["4","5"]`). |
| `proxyConfiguration` | object | Residential | Apify proxy. Residential is strongly recommended. |

### Output

Each record contains up to 22 structured fields. You can download the dataset in JSON, CSV, Excel, XML, or HTML.

| Field | Type | Description |
|---|---|---|
| `name` | string | Hotel or property name |
| `url` | string | Canonical Booking.com URL (tracking params stripped) |
| `hotelId` | number | Booking.com internal hotel ID (used for dedupe) |
| `location` | string | Neighborhood and city |
| `address` | string | Street / area address ← **extra over `automation-lab/booking-scraper`** |
| `starRating` | number | Star rating (1–5) |
| `reviewScore` | number | Guest review score (0–10) |
| `reviewCount` | number | Total number of guest reviews |
| `reviewScoreWord` | string | Rating label (e.g., "Excellent", "Very Good") |
| `price` | number | Total price for the stay |
| `pricePerNight` | number | Price per night |
| `currency` | string | Currency code (USD, EUR, GBP, etc.) |
| `roomType` | string | Recommended room/unit type |
| `freeCancellation` | boolean | Whether free cancellation is available |
| `breakfastIncluded` | boolean | Whether breakfast is included |
| `photoUrl` | string | Hotel photo URL |
| `propertyType` | string | Property type (Hotel, Apartment, etc.) |
| `coordinates` | object | `{ latitude, longitude }` ← **extra over `automation-lab/booking-scraper`** |
| `checkin` | string | Check-in date (YYYY-MM-DD) |
| `checkout` | string | Check-out date (YYYY-MM-DD) |
| `distanceFromCenter` | string | Distance from city center |
| `scrapedAt` | string | ISO 8601 timestamp |

Example output:

```json
{
    "name": "citizenM London Shoreditch",
    "url": "https://www.booking.com/hotel/gb/citizenm-london-shoreditch.html",
    "hotelId": 189710206,
    "location": "Hackney, London",
    "address": "Hackney, London",
    "starRating": null,
    "reviewScore": 8.7,
    "reviewCount": 3356,
    "reviewScoreWord": "Excellent",
    "price": 224,
    "pricePerNight": 112,
    "currency": "USD",
    "roomType": "Comfort Double Room",
    "freeCancellation": true,
    "breakfastIncluded": false,
    "photoUrl": "https://cf.bstatic.com/xdata/images/hotel/square240/772469398.webp",
    "propertyType": null,
    "coordinates": null,
    "checkin": "2026-06-01",
    "checkout": "2026-06-03",
    "distanceFromCenter": "2.4 miles from downtown",
    "scrapedAt": "2026-05-22T16:00:00.000Z"
}
```

### How much does it cost to scrape Booking.com?

This actor uses **pay-per-event pricing** — you pay only for what you scrape. No monthly subscription. All platform costs (compute, residential proxy, storage) are included.

| Event | Free | Business Gold |
|---|---|---|
| Actor start (per run) | $0.0575 | $0.030 |
| Per hotel scraped (deduped by `hotelId`) | $9.76 / 1,000 | $5.09 / 1,000 |

Real-world cost examples (Free tier):

| Search | Results | Estimated cost |
|---|---|---|
| London, 10 hotels | 10 | ~$0.15 |
| Paris, 30 hotels | 30 | ~$0.35 |
| New York, 75 hotels | 75 | ~$0.79 |
| Tokyo, 100 hotels | 100 | ~$1.03 |

### Tips for best results

- **Target specific hotels with direct URLs** — for known properties, `startUrls` is more reliable than name search.
- **Start small** — test with `maxResults: 10` before scaling up.
- **Set explicit dates** — Booking prices vary significantly by date; always pin `checkin`/`checkout` for accurate pricing.
- **Use price + star filters** — `minPrice`/`maxPrice` and `starsFilter` narrow results without paying for irrelevant rows.
- **Residential proxies recommended** — Booking's AWS WAF blocks datacenter IPs fast.

### API usage

cURL:

```sh
curl -X POST "https://api.apify.com/v2/acts/<account>~booking-scraper/runs?token=YOUR_API_TOKEN&waitForFinish=300" \
  -H "Content-Type: application/json" \
  -d '{"locationQuery":"London","checkin":"2026-06-01","checkout":"2026-06-03","maxResults":50,"currency":"USD"}'
```

Node.js:

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('<account>/booking-scraper').call({
    locationQuery: 'London',
    checkin: '2026-06-01',
    checkout: '2026-06-03',
    maxResults: 50,
    currency: 'USD',
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Found ${items.length} hotels`);
```

Python:

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_API_TOKEN')
run = client.actor('<account>/booking-scraper').call(run_input={
    'locationQuery': 'London',
    'checkin': '2026-06-01',
    'checkout': '2026-06-03',
    'maxResults': 50,
    'currency': 'USD',
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(f'Found {len(items)} hotels')
```

### FAQ

**How does this scraper handle Booking.com's anti-bot protection?** Booking uses AWS WAF to block automated requests. This scraper uses a full Playwright browser with residential proxies and anti-detection flags, which bypasses the WAF reliably.

**Can I scrape hotels in any country?** Yes. Enter any city, region, or country in `locationQuery`. Booking covers 2.5M+ properties worldwide.

**How many hotels can I scrape in one run?** Set `maxResults: 0` for unlimited (hard-capped at 1000 per run for safety). Typical city searches return 200–1,000+ properties.

**How do I scrape a specific hotel?** Use `startUrls` with the property's direct Booking.com URL (e.g., `https://www.booking.com/hotel/gb/the-savoy.html`).

**Can I filter by price or star rating?** Yes — `minPrice`, `maxPrice`, and `starsFilter` (e.g., `["4","5"]`).

**What if Booking shows a CAPTCHA?** The scraper detects WAF challenge pages and automatically rotates the residential IP, retrying up to 3 times per request.

**Why are some fields null?** Booking doesn't show every field for every property. Non-rated properties (hostels, apartments) often lack `starRating`. `coordinates` are populated when Booking exposes lat/lng in the search tile or in the JSON-LD on the property page.

**Does the dedupe affect the result count?** Yes — if a property appears twice in a single run (e.g., sponsored slot + organic placement), it's pushed and charged once.

### Legality

This scraper only accesses publicly available hotel listing data from Booking.com search results. It does not bypass logins, CAPTCHAs, or access controls. Web scraping of publicly available data is generally legal, but you should review [Booking.com's Terms of Service](https://www.booking.com/content/terms.html) and applicable laws in your jurisdiction. Use the data responsibly and in compliance with privacy regulations like GDPR.

# Actor input Schema

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

List of direct Booking.com hotel page URLs to scrape (e.g., https://www.booking.com/hotel/gb/the-savoy.html). If provided, the scraper visits each URL directly instead of running a location search. Check-in/check-out dates and guest counts still apply for pricing.

## `locationQuery` (type: `string`):

City, region, country, or hotel name to search (e.g., 'London', 'Paris, France', 'The Savoy London'). Hotel names are resolved via Booking.com search. Required if no Start URLs are provided.

## `checkin` (type: `string`):

Check-in date in YYYY-MM-DD format. Defaults to tomorrow if not specified.

## `checkout` (type: `string`):

Check-out date in YYYY-MM-DD format. Defaults to 2 days after check-in if not specified.

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

Number of adult guests.

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

Number of rooms.

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

Number of children.

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

Maximum number of hotels to return. Set to 0 for unlimited (capped at 1000 hard limit). Applies to location search only — startUrls always scrape every provided URL.

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

Sort order for search results.

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

Currency code for prices (e.g., USD, EUR, GBP).

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

Language for results (e.g., en-us, de, fr, es, it, pt-br, ja, zh-cn).

## `minPrice` (type: `integer`):

Minimum price per night filter (in the selected currency).

## `maxPrice` (type: `integer`):

Maximum price per night filter (in the selected currency).

## `starsFilter` (type: `array`):

Filter by hotel star rating. Enter values 1-5 to include (e.g., \['4', '5'] for 4- and 5-star hotels only).

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

Apify proxy. Residential proxies are strongly recommended — Booking.com's AWS WAF blocks datacenter IPs almost immediately. Leaving the default keeps you on RESIDENTIAL.

## Actor input object example

```json
{
  "locationQuery": "London",
  "checkin": "2026-06-01",
  "checkout": "2026-06-03",
  "adults": 2,
  "rooms": 1,
  "children": 0,
  "maxResults": 100,
  "sortBy": "popularity",
  "currency": "USD",
  "language": "en-us",
  "maxPrice": 300,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Scraped Booking.com hotels. One record per unique hotelId across the run.

# 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 = {
    "locationQuery": "London",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booking.com Scraper (Pay-Per-Event)",
        "description": "Scrape Booking.com hotel search results or direct hotel pages. Returns 22 fields per hotel including prices, ratings, reviews, location, address, and coordinates. Run-scoped dedupe by hotelId. Pay-per-event pricing — only pay for the hotels you actually scrape.",
        "version": "0.2",
        "x-build-id": "33IAL9GQc0Mtoybzn"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/prodiger~booking-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-prodiger-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/prodiger~booking-scraper/runs": {
            "post": {
                "operationId": "runs-sync-prodiger-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/prodiger~booking-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-prodiger-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": {
                    "startUrls": {
                        "title": "Direct hotel URLs",
                        "type": "array",
                        "description": "List of direct Booking.com hotel page URLs to scrape (e.g., https://www.booking.com/hotel/gb/the-savoy.html). If provided, the scraper visits each URL directly instead of running a location search. Check-in/check-out dates and guest counts still apply for pricing.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "locationQuery": {
                        "title": "Location or hotel name",
                        "type": "string",
                        "description": "City, region, country, or hotel name to search (e.g., 'London', 'Paris, France', 'The Savoy London'). Hotel names are resolved via Booking.com search. Required if no Start URLs are provided."
                    },
                    "checkin": {
                        "title": "Check-in date",
                        "type": "string",
                        "description": "Check-in date in YYYY-MM-DD format. Defaults to tomorrow if not specified."
                    },
                    "checkout": {
                        "title": "Check-out date",
                        "type": "string",
                        "description": "Check-out date in YYYY-MM-DD format. Defaults to 2 days after check-in if not specified."
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of adult guests.",
                        "default": 2
                    },
                    "rooms": {
                        "title": "Rooms",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Number of rooms.",
                        "default": 1
                    },
                    "children": {
                        "title": "Children",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of children.",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of hotels to return. Set to 0 for unlimited (capped at 1000 hard limit). Applies to location search only — startUrls always scrape every provided URL.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "popularity",
                            "price",
                            "bayesian_review_score",
                            "class",
                            "distance"
                        ],
                        "type": "string",
                        "description": "Sort order for search results.",
                        "default": "popularity"
                    },
                    "currency": {
                        "title": "Currency",
                        "type": "string",
                        "description": "Currency code for prices (e.g., USD, EUR, GBP).",
                        "default": "USD"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language for results (e.g., en-us, de, fr, es, it, pt-br, ja, zh-cn).",
                        "default": "en-us"
                    },
                    "minPrice": {
                        "title": "Min price per night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price per night filter (in the selected currency)."
                    },
                    "maxPrice": {
                        "title": "Max price per night",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price per night filter (in the selected currency)."
                    },
                    "starsFilter": {
                        "title": "Star rating filter",
                        "type": "array",
                        "description": "Filter by hotel star rating. Enter values 1-5 to include (e.g., ['4', '5'] for 4- and 5-star hotels only).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. Residential proxies are strongly recommended — Booking.com's AWS WAF blocks datacenter IPs almost immediately. Leaving the default keeps you on RESIDENTIAL.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
