# Booking.com Hotel Scraper (`fetch_cat/booking-com-hotels-scraper`) Actor

Scrape Booking.com hotel prices, availability, ratings, rooms, policies, facilities, photos, and review summaries. Export CSV, JSON, Excel, or use the API.

- **URL**: https://apify.com/fetch\_cat/booking-com-hotels-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Travel, E-commerce, Developer tools
- **Stats:** 1 total users, 1 monthly users, 89.5% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 hotel scrapeds

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Booking.com Hotel Scraper

Scrape Booking.com hotel listings for travel research, price monitoring, and structured hotel datasets.

### What does this Actor do?

Booking.com Hotel Scraper returns structured hotel listings by destination or direct hotel URL. The default output is deliberately lean: identity, canonical URL, property type, location, rating, availability, and price context. Rooms, policies, facility highlights, photos, and review details are optional per-hotel enrichments.

Use it for hotel supply research, price snapshots, destination comparisons, lead lists, and travel-data pipelines. It does not sign in, reserve rooms, solve challenges, or collect private traveler data.

### Who is it for?

- Travel and hospitality analysts comparing public hotel supply and prices.
- Revenue and market-research teams building repeatable destination snapshots.
- Data engineers feeding hotel identity, availability, and price context into internal pipelines.
- AI-agent builders who need schema-described Booking.com listing data through API or MCP.

### Input example

```json
{
  "destination": "Lisbon",
  "checkIn": "2026-08-15",
  "checkOut": "2026-08-17",
  "adults": 2,
  "children": 1,
  "childrenAges": [5],
  "rooms": 1,
  "currency": "USD",
  "language": "en-us",
  "maxHotelsPerSearch": 10,
  "maxCandidatesPerSearch": 50,
  "maxHotelsPerRun": 10
}
```

This saves at most 10 lean hotel rows. No per-hotel enrichment is requested.

### Ready-to-run examples

- [Search Lisbon hotels and export prices](https://apify.com/fetch_cat/booking-com-hotels-scraper/examples/search-lisbon-hotels) — save five lean listing rows with availability and price context.
- [Track Paris hotel prices in euros](https://apify.com/fetch_cat/booking-com-hotels-scraper/examples/search-paris-hotels-in-euros) — take a two-night EUR snapshot 14 days after each run starts.
- [Collect complete details for one Lisbon hotel](https://apify.com/fetch_cat/booking-com-hotels-scraper/examples/collect-lisbon-hotel-details) — use a direct hotel URL and request every optional enrichment independently.
- [Find family hotels in Barcelona](https://apify.com/fetch_cat/booking-com-hotels-scraper/examples/search-family-hotels-barcelona) — search for two adults and one eight-year-old child with free cancellation.
- [Compare Lisbon and Porto hotels](https://apify.com/fetch_cat/booking-com-hotels-scraper/examples/compare-lisbon-porto-hotels) — compare highly rated hotels and apartments across two destinations.

### Choose the product surface

Lean listing/search data is the default. Enable only the extra surfaces your workflow needs:

```json
{
  "hotelUrls": [
    "https://www.booking.com/hotel/pt/chiado-arty-flats.html"
  ],
  "checkIn": "2026-08-15",
  "checkOut": "2026-08-17",
  "adults": 2,
  "children": 0,
  "childrenAges": [],
  "rooms": 1,
  "enrichRooms": true,
  "enrichPolicies": true,
  "enrichFacilities": true,
  "enrichPhotos": true,
  "enrichReviews": true,
  "maxHotelsPerRun": 1
}
```

Each selected enrichment runs independently. If rooms fail but photos succeed, the actor keeps the base hotel row, reports the rooms warning on that row, and keeps the successful photos. There is no enrichment-specific charge event, so a failed enrichment is never charged separately.

`enrichReviews` returns the review score/count, labels, secondary score, and available summary metadata. It does not return individual guest review text.

### Dates for scheduled runs

Use fixed `checkIn` and `checkOut` dates for one-off snapshots. For schedules, use a relative pair that resolves once when each run starts:

```json
{
  "destination": "Paris",
  "checkInOffsetDays": 14,
  "stayNights": 3,
  "currency": "EUR",
  "sortBy": "PRICE_ASC",
  "maxHotelsPerSearch": 5,
  "maxCandidatesPerSearch": 50,
  "maxHotelsPerRun": 5
}
```

Do not combine the two date modes. Every row records the mode, relative values, resolved dates, and resolution time in `provenance`.

### Search targets

Provide at least one of:

- `destination`: one city, region, landmark, or hotel phrase.
- `destinations`: multiple independent destination searches.
- `hotelUrls`: direct Booking.com `/hotel/{country}/{slug}.html` URLs.

Direct hotel URLs can be more deterministic than broad destination searches because the actor resolves and matches the stable hotel ID before accepting a row. Neither direct URLs nor destination searches should be treated as immune to Booking.com blocking, challenges, redirects, inventory changes, or schema changes.

### Input settings

| Input | Type | Meaning |
| --- | --- | --- |
| `destination` | string | One destination search phrase. |
| `destinations` | string\[] | Multiple destination searches. |
| `hotelUrls` | string\[] | Direct Booking.com hotel URLs; each can return at most one hotel. |
| `checkIn`, `checkOut` | string | Optional `YYYY-MM-DD` range. Supply both or neither. |
| `checkInOffsetDays`, `stayNights` | integer | Relative date pair for schedules: offset 0–365 and stay 1–30 nights. |
| `adults` | integer | Adult guests; default `2`. |
| `children` | integer | Child guests; default `0`. |
| `childrenAges` | integer\[] | Exactly one age, 0–17, for every child. |
| `rooms` | integer | Rooms requested; default `1`. |
| `currency` | string | Requested three-letter currency. Returned currency is recorded separately. |
| `language` | string | Requested Booking.com locale, such as `en-us` or `de-de`. |
| `countryCode` | string | Optional country for the existing residential proxy route. It is not a blocking guarantee. |
| `propertyTypes` | string\[] | Optional categories such as `HOTEL`, `APARTMENT`, or `HOSTEL`. |
| `minReviewScore` | integer | Optional minimum of `6`, `7`, `8`, or `9`. |
| `starRatings` | integer\[] | Optional exact star ratings from 1 to 5. |
| `freeCancellationOnly` | boolean | Keep listings exposing free cancellation in the requested stay context. |
| `minPricePerNight`, `maxPricePerNight` | number | Optional bounds calculated from displayed stay total ÷ nights; dates are required. |
| `sortBy` | string | `RECOMMENDED`, `PRICE_ASC`, `TOP_REVIEWED`, `STARS_DESC`, or `STARS_ASC`. |
| `maxCandidatesPerSearch` | integer | Unpaid candidate rows evaluated per destination; 1–500 and at least the saved per-search cap. |
| `maxHotelsPerSearch` | integer | Maximum rows from each destination search; 1–100. |
| `maxHotelsPerRun` | integer | Hard saved-and-charged row cap across the whole run; 1–100. |
| `enrichRooms` | boolean | Room configurations and matched offer data. |
| `enrichPolicies` | boolean | Cancellation, prepayment, pet, and meal-plan signals. |
| `enrichFacilities` | boolean | Facility and property-USP highlights. |
| `enrichPhotos` | boolean | Available hotel photos. |
| `enrichReviews` | boolean | Review labels, secondary score, and summary metadata. |

Backward compatibility: `maxItems` sets both limits and `includeDetails` enables all enrichments. Do not combine `maxItems` with either explicit limit. New integrations should use the explicit fields.

### Limits and charging

The three limits have different scopes:

- `maxCandidatesPerSearch` caps unpaid candidate rows evaluated for each destination while applying filters.
- `maxHotelsPerSearch` stops each destination search independently.
- `maxHotelsPerRun` is the total number of dataset rows that can be saved and charged across all destinations and direct hotel URLs.

Duplicate stable hotel IDs are saved once per run. Direct hotel URL targets return at most one row each. `RUN_SUMMARY` records all three limits plus `candidatesEvaluated`, `filteredOutRows`, `saved`, and `chargedHotels`. If filters consume the candidate allowance before any row can be saved, the run reports `INPUT_CONFIGURATION_LIMIT_REACHED` instead of a misleading empty success.

### Pricing

Pricing uses these events:

| Event | Price |
| --- | --- |
| Start | $0.0005 once per run |
| Hotel scraped — Free | $0.0029 per saved row |
| Hotel scraped — Bronze | $0.0027 per saved row |
| Hotel scraped — Silver | $0.0024 per saved row |
| Hotel scraped — Gold | $0.0020 per saved row |
| Hotel scraped — Platinum | $0.0015 per saved row |
| Hotel scraped — Diamond | $0.0010 per saved row |

The `hotel-scraped` event is emitted atomically with the base dataset row. Optional enrichments do not have separate charge events. Residential proxy traffic is part of the actor’s operating route.

### Output fields

Each dataset item includes:

- Stable identity when exposed: `hotelId`, `bookingId`, `canonicalUrl`, and legacy alias `url`.
- Search provenance: requested/applied destination, fixed or relative date mode, resolved dates/time, adults, children, `childrenAges`, rooms, currency, language, filters, and sorting.
- Base listing data: hotel name, property type, free-cancellation signal, address, city, country code, coordinates, stars, rating, and review count.
- Field-level availability context: dates, occupancy, status, and Booking.com message.
- Field-level price context: requested/returned currency, total-stay basis, nights, displayed total, transparently derived per-night price, original total, separately excluded taxes/fees, and inclusion status.
- Optional `rooms`, `policies`, `facilities`, `photos`, and `reviews` data.
- Per-enrichment status, row-level warnings, result rank, and `scrapedAt`.

### Output example

Example dataset item excerpt:

```json
{
  "hotelName": "Chiado Arty Flats",
  "hotelId": 1814397,
  "canonicalUrl": "https://www.booking.com/hotel/pt/chiado-arty-flats.html",
  "childrenAges": [5],
  "price": "$400.03",
  "currency": "USD",
  "priceContext": {
    "status": "AVAILABLE",
    "basis": "TOTAL_STAY",
    "checkIn": "2026-08-15",
    "checkOut": "2026-08-17",
    "nights": 2,
    "requestedCurrency": "USD",
    "returnedCurrency": "USD",
    "total": { "amount": 400.03, "formatted": "$400.03", "currency": "USD" },
    "pricePerNight": { "amount": 200.02, "formatted": null, "currency": "USD" },
    "pricePerNightBasis": "DISPLAYED_TOTAL_DIVIDED_BY_NIGHTS",
    "excludedTaxesAndFees": { "amount": 42.31, "formatted": "$42.31", "currency": "USD" },
    "totalIncludesTaxesAndFees": false
  },
  "availabilityContext": {
    "status": "AVAILABLE",
    "adults": 2,
    "children": 1,
    "childrenAges": [5],
    "rooms": 1
  },
  "enrichment": {
    "rooms": { "requested": false, "status": "NOT_REQUESTED", "warning": null },
    "policies": { "requested": false, "status": "NOT_REQUESTED", "warning": null },
    "facilities": { "requested": false, "status": "NOT_REQUESTED", "warning": null },
    "photos": { "requested": false, "status": "NOT_REQUESTED", "warning": null },
    "reviews": { "requested": false, "status": "NOT_REQUESTED", "warning": null }
  },
  "warnings": [],
  "scrapedAt": "2026-07-20T12:00:00.000Z"
}
```

`priceContext.total` is the total Booking.com displayed for the requested stay. `pricePerNight` is that displayed total divided by the number of nights and rounded to two decimals; it is not a separately quoted rate. `excludedTaxesAndFees` remains separate and is never silently added.

### Run outcomes

Read `RUN_SUMMARY` from the default key-value store. The status is explicit:

| Status | Meaning |
| --- | --- |
| `SUCCEEDED` | Requested base rows were saved without warnings. |
| `NO_MATCHES` | The target resolved but returned no matching hotels, or no destination/hotel could be resolved. A zero-row run fails instead of reporting success. |
| `SOLD_OUT` | The requested dates/occupancy produced only sold-out results or no availability. |
| `TARGET_CHALLENGE` | Booking.com returned an access challenge. |
| `PARTIAL` | At least one base row was saved, but a target or optional enrichment failed, or the safe deadline was reached. |
| `INPUT_CONFIGURATION_LIMIT_REACHED` | Input validation, a documented target/input limit, or the candidate allowance before the first filtered match was reached. Validation errors occur before the start event. |
| `FAILED` | An unexpected target, transport, storage, or response error stopped the run. |

When optional work fails, every retained row has a structured warning with `scope`, `code`, `message`, and `retryable`. Deadline-limited runs also write `PENDING_WORK`.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/booking-com-hotels-scraper').call({
  destination: 'Lisbon',
  maxHotelsPerSearch: 10,
  maxCandidatesPerSearch: 50,
  maxHotelsPerRun: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("$APIFY_TOKEN")
run = client.actor("fetch_cat/booking-com-hotels-scraper").call(run_input={
    "destination": "Lisbon",
    "maxHotelsPerSearch": 10,
    "maxCandidatesPerSearch": 50,
    "maxHotelsPerRun": 10,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~booking-com-hotels-scraper/runs?token=$APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"destination":"Lisbon","maxHotelsPerSearch":10,"maxCandidatesPerSearch":50,"maxHotelsPerRun":10}'
```

### MCP and AI agents

The input, output, and dataset schemas are published for OpenAPI and Apify MCP use. Ask an agent to start with lean output and opt into only the enrichments it needs.

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors fetch_cat/booking-com-hotels-scraper
```

Equivalent MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "fetch_cat/booking-com-hotels-scraper"],
      "env": { "APIFY_TOKEN": "$APIFY_TOKEN" }
    }
  }
}
```

Example prompts:

- “Collect 10 lean Booking.com hotel rows for Lisbon and preserve total-price/tax context.”
- “Schedule a Paris snapshot 14 days ahead for a three-night stay, sorted by price.”
- “Find 4- and 5-star Lisbon hotels rated 8+ and evaluate at most 50 candidates.”
- “Resolve this direct Booking.com hotel URL and add rooms and policies.”
- “Compare three destinations, cap each search at 5 hotels, and cap the whole charged run at 12 rows.”

### Troubleshooting

- `TARGET_CHALLENGE`: retry later or use a smaller target set. The actor does not solve target challenges or promise an unblock.
- `NO_MATCHES`: verify spelling or use a direct hotel URL when you already know the property.
- `SOLD_OUT`: verify dates, guest ages, and occupancy, or retry without dates to collect identity-only listings.
- `PARTIAL`: inspect row `warnings` and each `enrichment` status; successful base data remains usable.
- `INPUT_CONFIGURATION_LIMIT_REACHED`: check `childrenAges`, the chosen date mode, target count, price range, and all three explicit limits. With filters, raise `maxCandidatesPerSearch` or relax the filters.
- Returned currency differs from requested currency: use `provenance.requested.currency` and `priceContext.returnedCurrency` rather than assuming conversion.

### FAQ

**Can I use this through the API or MCP?** Yes. The Actor publishes input, output, and dataset schemas for Apify API, OpenAPI, and MCP clients.

**Should I use a destination or a direct hotel URL?** Use a destination to discover supply and a direct URL when you already know the property. Direct URLs are generally more deterministic, but both modes can be redirected, challenged, or blocked.

**Are optional enrichments charged separately?** No. The Actor charges the base row only when it is saved. There are no rooms, policies, facilities, photos, or reviews charge events.

**Can scheduled runs keep dates current?** Yes. Use `checkInOffsetDays` with `stayNights`; each run records the resolved dates and time. Fixed and relative date modes cannot be combined.

**Does `enrichReviews` return guest review text?** No. It returns listing-level review details and available summary metadata. Use the related reviews-specific Actor when individual public reviews are required.

**Why can the returned currency differ from my input?** Currency is controlled by Booking.com’s response context. The Actor preserves both the requested and returned values instead of claiming a conversion it did not perform.

**What is the alternative when Booking.com challenges a run?** Retry later with a smaller scope, or use Booking.com’s official partner APIs if you have the required commercial access. This Actor does not bypass challenges.

### Legality and responsible use

Use this actor for lawful public-data research. Follow Booking.com’s terms, applicable laws, and privacy requirements. Do not use it for personal traveler data, reservations, account-only data, abusive traffic, or attempts to bypass access controls.

### Related actors

- [Booking.com Reviews Scraper](https://apify.com/fetch_cat/booking-reviews-scraper)
- [Agoda Hotels Scraper](https://apify.com/fetch_cat/agoda-hotels-scraper)
- [Airbnb Listings Scraper](https://apify.com/fetch_cat/airbnb-listings-scraper)
- [Google Flights Scraper](https://apify.com/fetch_cat/google-flights-scraper)

### Support

For a reproducible issue, include the Apify run ID or run URL, exact input JSON, `RUN_SUMMARY`, expected output, actual output, and a reproducible public URL when one exists. Never post API tokens, cookies, or private traveler data.

# Actor input Schema

## `destination` (type: `string`):

One city, region, landmark, or hotel search phrase. For multiple searches, use destinations.

## `destinations` (type: `array`):

Optional list of destination searches. Each entry has its own maxHotelsPerSearch cap.

## `hotelUrls` (type: `array`):

Optional canonical or redirected Booking.com /hotel/{country}/{slug}.html URLs. Direct targets are often more deterministic than destination search, but can still be blocked by Booking.com.

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

Check-in in YYYY-MM-DD. Supply both dates or neither.

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

Check-out in YYYY-MM-DD. Supply both dates or neither.

## `checkInOffsetDays` (type: `integer`):

For scheduled runs, resolve check-in this many days after the run starts. Use together with stayNights instead of checkIn/checkOut.

## `stayNights` (type: `integer`):

For scheduled runs, resolve check-out from the relative check-in date. Use together with checkInOffsetDays.

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

Adult guests used for availability and price context.

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

Number of children. Must equal the number of entries in childrenAges.

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

One age from 0 to 17 for every child, for example \[4, 9].

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

Rooms used for availability and price context.

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

Three-letter requested currency. The returned currency is recorded separately in every row.

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

Booking.com language parameter, for example en-us or de-de. Provenance records the applied value.

## `countryCode` (type: `string`):

Optional ISO country code for the existing residential proxy route. This does not guarantee target access.

## `propertyTypes` (type: `array`):

Optional property categories. Multiple values are combined as alternatives.

## `minReviewScore` (type: `integer`):

Optional minimum guest review score.

## `starRatings` (type: `array`):

Optional exact property star ratings as integers from 1 to 5, for example \[4, 5]. Multiple values are combined as alternatives.

## `freeCancellationOnly` (type: `boolean`):

Keep only listings currently exposing a free-cancellation option for the requested stay context.

## `minPricePerNight` (type: `number`):

Optional lower bound in the requested/returned currency. Calculated from the displayed stay total divided by nights; requires dates.

## `maxPricePerNight` (type: `number`):

Optional upper bound in the requested/returned currency. Calculated from the displayed stay total divided by nights; requires dates.

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

Requested result order. The applied sorter is recorded in provenance.

## `maxCandidatesPerSearch` (type: `integer`):

Maximum unpaid candidate rows inspected per destination while applying filters. This must be at least maxHotelsPerSearch and does not change the saved/charged cap.

## `maxHotelsPerSearch` (type: `integer`):

Maximum rows from each destination target. Direct hotel URL targets can return at most one row each.

## `maxHotelsPerRun` (type: `integer`):

Hard cap across every destination and hotel URL in this run. A hotel-scraped charge occurs only when that base row is saved.

## `enrichRooms` (type: `boolean`):

Fetch room configurations and matched offers independently for each hotel.

## `enrichPolicies` (type: `boolean`):

Fetch cancellation, prepayment, pet, and meal-plan signals independently.

## `enrichFacilities` (type: `boolean`):

Fetch facility/USP highlights independently.

## `enrichPhotos` (type: `boolean`):

Fetch the available hotel photo set independently.

## `enrichReviews` (type: `boolean`):

Fetch score labels, secondary scores, and available review summary metadata independently. This does not return individual guest review text.

## `maxItems` (type: `integer`):

Legacy alias that sets both limits. Do not combine it with maxHotelsPerSearch or maxHotelsPerRun.

## `includeDetails` (type: `boolean`):

Legacy switch that enables every enrichment unless an individual enrichment flag overrides it.

## Actor input object example

```json
{
  "destination": "Lisbon",
  "adults": 2,
  "children": 0,
  "childrenAges": [],
  "rooms": 1,
  "currency": "USD",
  "language": "en-us",
  "freeCancellationOnly": false,
  "sortBy": "RECOMMENDED",
  "maxCandidatesPerSearch": 20,
  "maxHotelsPerSearch": 5,
  "maxHotelsPerRun": 5,
  "enrichRooms": false,
  "enrichPolicies": false,
  "enrichFacilities": false,
  "enrichPhotos": false,
  "enrichReviews": false
}
```

# Actor output Schema

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

No description

## `runSummary` (type: `string`):

No description

## `pendingWork` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "destination": "Lisbon",
    "currency": "USD",
    "language": "en-us",
    "maxCandidatesPerSearch": 20,
    "maxHotelsPerSearch": 5,
    "maxHotelsPerRun": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/booking-com-hotels-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 = {
    "destination": "Lisbon",
    "currency": "USD",
    "language": "en-us",
    "maxCandidatesPerSearch": 20,
    "maxHotelsPerSearch": 5,
    "maxHotelsPerRun": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/booking-com-hotels-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 '{
  "destination": "Lisbon",
  "currency": "USD",
  "language": "en-us",
  "maxCandidatesPerSearch": 20,
  "maxHotelsPerSearch": 5,
  "maxHotelsPerRun": 5
}' |
apify call fetch_cat/booking-com-hotels-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/FTUBcY2S2kR7Y71uI/builds/MhtIL98whsXYcdlBY/openapi.json