# Hilton Room Rates Scraper (`boncross/hilton-room-rates`) Actor

Scrape every room Hilton is selling for a hotel and your dates. Just add hotel codes or hilton.com URLs and get nightly rate, stay total, Honors points cost, bed count, amenities, image and rate plan names. Points rows carry the cash price beside the points. $3.50 per 1,000 priced hotel-stays.

- **URL**: https://apify.com/boncross/hilton-room-rates.md
- **Developed by:** [BonCross API](https://apify.com/boncross) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 hotel-priceds

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Hilton Room Rates Scraper

### What is Hilton Room Rates Scraper?

For any Hilton hotel and dates, Hilton Room Rates Scraper returns each room on sale with its nightly rate and stay total. Ask for Honors points as well and you see what the same room costs as an award night, with the cash price on the same row. You supply hotel codes or hilton.com links and your dates. It works for all Hilton brands, from Hampton and Hilton Garden Inn to Conrad, Waldorf Astoria and LXR.

What a cheapest-price lookup won't give you:

- **The whole room list, and the whole rate list when you want it.** By default you get one row per room at the rate Hilton shows first. Switch on every rate plan and a single stay at a Times Square hotel returned 374 cash rates over 33 rooms, a London hotel 154 over 10 (5 October 2026).
- **Points and cash side by side.** A points row has points per night, the total, and the points for each night separately when an award price changes mid-stay.
- **A month of arrival dates in one go.** The price calendar gives the lowest nightly rate for each date, with rooms left at that rate. We checked 27 dates against the room list on 6 October 2026 and all 27 cash prices matched.
- **It's quick at volume.** 180 hotel-stays (918 rooms, 14 sold out) came back in about 8 seconds.
- **$3.50 per 1,000 priced hotel-stays** on the Free plan, $2.60 on Business, however many rooms a stay returns. A sold-out stay costs $0.0005 and a stay Hilton never answered costs nothing.

**BonCross Verified** means we tested this actor against the live site before release and kept the record:

- 37 of 37 live checks on its inputs and filters passed on 8 October 2026
- 6 hotels run on 7 October 2026 on 3 stays each: 104 rates, 5 sold-out answers
- Charges matched the stays: 18 checked, 13 priced
- A stay Hilton cannot answer gets an uncharged row saying why

### Three ways to run it

**The room list (the default).** One row per room the hotel is selling for your stay, cheapest first, priced at its lead rate. This is what you want for watching a competitive set or checking whether accessible, suite or executive rooms are still on sale.

**Every rate plan.** Each room sells under several plans: flexible, advance purchase, non-refundable, breakfast included, member and special rates. Turn on "Every rate plan" and each one is a row with its own price and terms. Expect 10 to 30 times as many rows. Use it for rate-parity checks, or to see what an AAA, senior, government, travel agent, small business or corporate rate is worth against the public one.

**The monthly price calendar.** One row per hotel and arrival date: the lowest nightly rate for a stay of your length starting that day, its rate plan and room, and how many rooms are left at that rate. With points on, you also get the lowest award price per date. It's the fast way to find the cheap nights before pricing them in full.

In all three you can price several hotels and several date ranges in one run, choose cash, points or both, and have the actor remember the lowest rate between runs and report what moved.

### What room and rate data do you get?

| | |
|---|---|
| 🏨 Hotel name and hotel code | Brand code |
| 📅 Check-in, check-out and nights | Adults, children, child ages and rooms |
| 🛏 Room name and description | Room type code and category |
| Bed count | How many the room sleeps |
| ♿️ Accessible room flag | Suite and executive flags |
| Rate plan code, name and terms | The rate plan codes the room sells under |
| Lead rate flag, the rate Hilton shows first | Special rate type and advance-purchase flag |
| 💷 Nightly rate, as Hilton shows it | Stay total, tax included |
| Whether the nightly rate includes tax | Rate plan's own tax flag |
| 💵 Nightly rate in US dollars | Currency |
| Price after tax as shown | Service charge terms |
| ⭐️ Honors points per night | Total points for the stay |
| Points for each night of the stay | Flags for rates that change mid-stay |
| Amenities, highlights and attributes | 🖼 Room photograph |
| 📉 Lowest rate for the hotel and stay | Change since the last run |
| 🔗 Link to the booking page | Timestamp of the run |

### How to scrape Hilton room rates

1. [Create a free Apify account](https://console.apify.com/sign-up), then open [Hilton Room Rates Scraper](https://apify.com/boncross/hilton-room-rates).
2. Add hotels as Hilton hotel codes such as LONCWHI, or paste hilton.com URLs. The links [Hilton Hotel Search Scraper](https://apify.com/boncross/hilton-hotel-search) returns work as they are.
3. Set your check-in and check-out dates, guests and rooms.
4. Choose cash rates, Honors points, or both. If you want the cheapest rate for each arrival date in a month, turn on the monthly price calendar.
5. Click Start, then download the results as JSON, CSV, Excel, XML or HTML.

### ⬇️ Input

You give it hotels and a stay. A hotel is a Hilton hotel code or any hilton.com hotel or booking URL. The stay can be fixed dates, or a rolling one: a number of days ahead (default 30) and a number of nights (default 2). A stay is 1 to 30 nights.

Got more links than you'd want to paste? Start URLs loads them in bulk from a file, a Google Sheet or a remote list, and is combined with the Hotels box.

Three limits work together. "Maximum rooms per hotel-stay" keeps the cheapest rooms of each stay (0, the default, keeps them all). "Maximum hotel-stays for the whole run" caps the priced **hotel-stays**, and "Maximum rows for the whole run" caps the **rows**. The run stops at whichever it reaches first, and you aren't charged for anything past a cap.

| Field | Default | What it does |
|---|---|---|
| `hotels` | none | Hotel codes or hilton.com URLs |
| `startUrls` | `[]` | The same links, loaded in bulk |
| `maxRoomsPerHotel` | `0` | Rooms per hotel-stay, cheapest first, up to 200. 0 keeps all rooms |
| `maxItems` | `0` | Priced hotel-stays for the whole run. 0 means no limit |
| `maxRows` | `0` | Rows for the whole run. 0 means no limit |
| `checkIn` / `checkOut` | empty | `YYYY-MM-DD` |
| `checkInDaysAhead` / `nights` | `30` / `2` | The rolling window used when the dates are empty |
| `stays` | none | Several `{checkIn, checkOut}` ranges; replaces the single stay |
| `adults` / `rooms` / `childrenAges` | `2` / `1` / none | Adults per room (1 to 8), rooms (1 to 9), one age per child |
| `rateModes` | `["cash"]` | `cash`, `points`, or both |
| `specialRate` | `""` | `aaa`, `senior`, `governmentMilitary`, `travelAgent` or `smb` |
| `promoCode` / `corporateId` / `groupCode` | none | Price the stay on those terms |
| `includeUnavailable` | `false` | Keep rooms the hotel lists but is not selling for the dates |
| `allRatePlans` | `false` | Off: one row per room, its lead rate. On: one row per room and rate plan, at most the 250 cheapest per stay |
| `priceCalendar` | `false` | One row per hotel and arrival date, instead of the room list |
| `calendarMonths` | `1` | With the calendar: months to cover, from the month of the check-in date, up to 12 |
| `currency` | `USD` | Three-letter code; clear it for the hotel's own currency |
| `priceStoreName` / `onlyNewOrChanged` | none / `false` | Remember the lowest rate between runs; return only what moved |
| `includeRawData` | `false` | Add the untouched record as `raw` |
| `delayMs` | `0` | Optional pause before each call, 0 to 30,000 ms |
| `maxConcurrency` | `16` | Parallel requests, 1 to 32 |

Price one hotel for one stay:

```json
{
  "hotels": ["LONCWHI"],
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-12",
  "adults": 2,
  "rooms": 1
}
```

Compare several hotels across two date ranges, in cash and in points:

```json
{
  "hotels": ["LONCWHI", "HNLMOGV"],
  "stays": [
    { "checkIn": "2026-11-10", "checkOut": "2026-11-12" },
    { "checkIn": "2026-12-05", "checkOut": "2026-12-07" }
  ],
  "adults": 2,
  "rateModes": ["cash", "points"],
  "maxRows": 200
}
```

Award nights in points, with rates in pounds:

```json
{
  "hotels": ["LONCWHI"],
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-13",
  "rateModes": ["points"],
  "currency": "GBP"
}
```

Monitor a hotel daily and return only stays whose lowest rate moved:

```json
{
  "hotels": ["DXBGIGI"],
  "checkInDaysAhead": 30,
  "nights": 2,
  "priceStoreName": "hilton-prices",
  "onlyNewOrChanged": true
}
```

#### For developers

- `maxItems` counts priced hotel-stays: one hotel, one stay, one rate mode, with all its rooms. Sold-out and unchanged stays don't count towards it. In the price calendar each priced date counts as one.
- When `maxRows` falls partway through a stay, that stay is cut to fit, keeping its cheapest rates, and is billed as one stay. `maxRoomsPerHotel` keeps the cheapest rooms and, with `allRatePlans` on, all the rate plans of each kept room.
- With `allRatePlans` on, a stay keeps at most its 250 cheapest rates.
- Asking for both rate modes prices each hotel-stay twice, and each pass is billed as its own hotel-stay.
- `priceStoreName` names the store that remembers the lowest nightly rate per hotel and stay. `onlyNewOrChanged` needs it. The remembered figure is the nightly rate as Hilton shows it. A store written on 2 October 2026 holds a tax-included figure for that day and isn't compared: the next run reports no previous rate for those stays.
- If two stays of one hotel in a row get no answer, the hotel's remaining stays are skipped, each with an uncharged error row saying so. One answered stay resets the count.
- `maxConcurrency` (default 16, from 1 to 32) is how many requests run at once. `delayMs` (default 0) adds a pause before each, and values above 2,000 are treated as 2,000. We'd leave both alone.
- A run that the platform restarts carries on where it stopped. No stay is repeated or billed twice.
- `checkin` and `checkout` in lowercase are accepted too.

### ⬆️ Output

Each room is one row in the dataset, and the Output tab has an Overview table. Rows within a stay are cheapest first. If you ask for both rate types you get each room twice, marked by `rateMode`. Here's a points row from a real run, abridged:

```json
{
  "id": "LONCWHI-2026-11-10-2026-11-13-K1D-LV0-points",
  "hotelId": "LONCWHI",
  "hotelName": "Hilton London Canary Wharf",
  "brandCode": "HI",
  "url": "https://www.hilton.com/en/book/reservation/rooms/?ctyhocn=LONCWHI&arrivalDate=2026-11-10&departureDate=2026-11-13&room1NumAdults=2&numRooms=1&displayCurrency=GBP",
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-13",
  "nights": 3,
  "adults": 2,
  "children": 0,
  "childrenAges": [],
  "rooms": 1,
  "roomId": "K1D",
  "roomName": "King Deluxe Room",
  "roomDescription": "Treat yourself to this contemporary King Deluxe Room, starting at 33 sq. m./355 sq. ft. This spacious room has large windows and a king bed.…",
  "roomCategory": "guest",
  "accommodationCode": "STD",
  "numBeds": 1,
  "sleeps": 2,
  "isAccessible": false,
  "isSuite": false,
  "isExecutive": false,
  "ratePlanId": "LV0",
  "ratePlanName": "Flexible Rate",
  "ratePlanDescription": null,
  "specialRateType": null,
  "isAdvancePurchase": null,
  "isLeadRate": true,
  "currency": "GBP",
  "pricePerNight": 343.67,
  "priceTotal": 1031,
  "pricesIncludeTax": true,
  "pricePerNightUSD": 455.43,
  "pricePerNightText": "£344",
  "priceAfterTaxText": "£1,031",
  "isTaxIncluded": true,
  "isRateChanging": true,
  "serviceChargeDetails": null,
  "pointsPerNight": 176000,
  "pointsTotal": 528000,
  "pointsNightly": [189000, 185000, 154000],
  "pointsRatePlanId": "HPPRP1",
  "hasPointsRate": true,
  "isPointsRateChanging": true,
  "isMemberRate": false,
  "isConfidentialRate": false,
  "isCommissionable": true,
  "ratePlanCount": 17,
  "ratePlanCodes": ["LV0", "HPPRP1", "R3X", "H3F", "RPLOCR", "RPLOSR", "…"],
  "amenities": ["Alarms - Audible", "Automatic Door Closer", "…"],
  "highlights": ["Sleeps 2", "Mini refrigerator", "Hand-held shower", "…"],
  "attributes": ["Sleeps 2", "Workspace", "Mini refrigerator"],
  "imageUrl": "https://www.hilton.com/im/en/LONCWHI/22774844/king-deluxe-room.jpg?…",
  "isLowestRate": false,
  "hotelLowestPerNight": 245.75,
  "hotelLowestPointsPerNight": 70000,
  "rateMode": "points",
  "scrapedAt": "2026-10-07T19:27:36.960Z"
}
```

The `id` is built from the hotel, the stay, the room and the rate plan. It's unique across a run, and you can join on it. Each row has one room photograph, in `imageUrl`.

**Lead rate, or one row per rate plan.** By default each room is priced at its lead rate, the plan Hilton shows first for it, and `isLeadRate` marks it. On a default cash row Hilton gives that public rate a code (`ratePlanId`) and no name, and `ratePlanName` is empty. With "Every rate plan" on, each plan is a row with its own price, name, terms (`ratePlanDescription`, `isAdvancePurchase`, `specialRateType`) and tax flag. Those three terms columns fill only in that mode. Award plans paid only in points are rows too, with `pricePerNight` empty and the points columns filled.

**Prices as Hilton shows them.** `pricePerNight` is the nightly rate exactly as Hilton's booking page shows it: the average over the nights where the rate changes during the stay, including any mandatory nightly charge Hilton adds. Whether it includes tax depends on the hotel, and `pricesIncludeTax` tells you. It's `false` where tax is added at checkout (the United States, the UAE and Japan, for example) and `true` where it's already inside (UK hotels, VAT included). `priceTotal` is Hilton's stay total for the room with all taxes and charges. `isTaxIncluded` is kept for compatibility and always equals `pricesIncludeTax`. `hotelLowestPerNight` is on the same basis as `pricePerNight`. `roomDescription` and `serviceChargeDetails` keep the light formatting tags Hilton writes them with.

**Points.** The points columns (`pointsPerNight`, `pointsTotal`, `pointsNightly`, `pointsRatePlanId` and `hotelLowestPointsPerNight`) are empty unless you choose the points rate type, which is off by default.

**Price memory.** With a price memory store named, each row of a stay seen before also has `previousLowestPerNight`, `previousScrapedAt`, `priceChange` and `priceChangePct`.

**Sold out, and stays with no answer.** A stay with nothing on sale returns one row with `isSoldOut: true`, `availabilityStatus`, the hotel code, dates and party. `hotelName` is empty on that row, because Hilton's sold-out answer doesn't include it. A hotel code Hilton doesn't know, a link that names no hotel, or a stay that couldn't be answered returns one row with `error` saying why.

#### The price calendar rows

With the calendar on, you get one row per hotel and arrival date in place of the room list. It runs from your check-in date to the end of that month, then through each further month you ask for (`calendarMonths`, default 1), for a stay of your length (`nights`). Dates before the check-in date are left out.

Each row has `checkIn`, `checkOut`, `pricePerNight` (the hotel's lowest nightly rate for that stay, on the same basis as the room list), `pricesIncludeTax`, `ratePlanId`, `ratePlanName`, `roomId`, `roomsLeft` (rooms left at that rate), `depositAmount`, `isAvailable`, `calendarMonth`, `calendarNights` (the stay length the dates in that row's month were priced for) and `isCalendarDay: true`. With the points rate type, a points row per date has `pointsFirstNight` (the lowest award price for the first night), `pointsRatePlanName` (the name of that award plan, null when Hilton gives none) and, for one-night stays, `pointsPerNight`.

Checked on 6 October 2026 against the room list for the same hotels and dates: 27 of 27 cash prices equal the lowest room rate, with the same rate plan and room, and 12 of 12 one-night points prices equal the lowest award.

```json
{
  "isCalendarDay": true,
  "hotelId": "NYCTEPO",
  "hotelName": "Tempo by Hilton New York Times Square",
  "checkIn": "2026-11-11",
  "checkOut": "2026-11-12",
  "nights": 1,
  "isAvailable": true,
  "currency": "USD",
  "pricePerNight": 399.79,
  "pricesIncludeTax": false,
  "ratePlanId": "HPPAP2",
  "ratePlanName": "Honors Discount Non-refundable",
  "roomId": "K1",
  "roomsLeft": 22,
  "calendarMonth": "2026-11",
  "rateMode": "cash"
}
```

### How much does it cost to scrape Hilton room rates?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.002 | $0.002 | $0.002 | $0.002 |
| `hotel-checked`, per hotel and stay Hilton answered, whatever the answer | $0.0005 | $0.0005 | $0.0005 | $0.0005 |
| `hotel-priced`, per hotel and stay that came back with rates, every room included | $0.003 | $0.0027 | $0.0024 | $0.0021 |
| `calendar-day`, per priced arrival date (price calendar only) | $0.0005 | $0.00045 | $0.0004 | $0.00035 |

Enterprise plans pay the Business price.

**$3.50 per 1,000 priced hotel-stays** on the Free plan, $2.60 on Business, however many rooms each one returns. Each rate type counts as its own hotel-stay. Proxy usage and platform usage are inside that price.

- One hotel, one stay: $0.002 + $0.0005 + $0.003 = **$0.0055** ($0.0046 on Business).
- Five hotels across two date ranges, in cash and in points, is twenty hotel-stays: $0.002 + 20 × $0.0035 = **$0.072** ($0.054 on Business).
- A thousand hotel-stays of which fifty are sold out: $0.002 + 1,000 × $0.0005 + 950 × $0.003 = **$3.352** ($2.497 on Business).
- One hotel's price calendar with 30 priced dates in the month: $0.002 + $0.0005 + 30 × $0.0005 = **$0.0175** ($0.013 on Business).

On the Free plan, Apify's $5 of monthly credits pays for about 69 runs the size of the second example, close to 1,400 priced hotel-stays.

#### What a sold-out or unanswered stay costs

You pay the full $0.0035 ($0.0026 on Business) only for a hotel-stay that returns rates.

- Hilton has nothing on sale for the dates: you get one row marked sold out and pay the $0.0005 check fee.
- The lowest rate hasn't moved and "Only new or changed" is on: you get no row and pay the $0.0005 check fee.
- The stay couldn't be answered, or Hilton doesn't know the code: you get one row saying why and pay nothing.

In the price calendar, `hotel-checked` is charged once per hotel and month Hilton answered and `calendar-day` once per priced date. `hotel-priced` isn't charged there, and a date with nothing on sale is returned free.

### How many rooms come back, and how fast?

A hotel-stay takes a second or two on its own, and stays are read many at a time.

| Run | Hotel-stays | Rows | Time |
|---|---|---|---|
| One hotel, one stay, 6 rooms kept | 1 | 6 | about 2 s |
| Eight hotels in four cities, four stays, cash, every room | 32 | 219 | 2.5 to 3.2 s |
| Eight hotels, two stays, cash and points, every room | 32 | 384 | about 4.5 s |
| Eight hotels, four stays, cash and points, every room | 64 | 796 | 5.4 s |
| 60 hotels, three stays | 180 | 918 rooms, 14 sold out | about 8 s |

Whole runs on Apify, measured on 1 and 2 October 2026.

On 6 October 2026, three hotels for one stay in cash and points returned 116 rows over 6 hotel-stays at one row per room. The same stays with every rate plan returned 1,253 rows a day earlier, 70 to 408 per hotel-stay. The price calendar answers a month of dates for one hotel in about a third of a second: three hotels, two months, cash and points came to 308 rows in under 3 seconds.

Batch your hotels. Dozens of hotel-stays in one run finish in seconds and pay one start fee, and many thousands fit inside the default one-hour run limit.

### Limitations

- Cancellation deadlines and the tax breakdown per rate aren't returned. `ratePlanDescription` has the plan's own terms in words.
- Taxes aren't itemised by kind. The nightly rate and the stay total with tax are both numbers, but Hilton doesn't publish the split between taxes, service charges and fees. `pricePerNightUSD` is on the same basis as `pricePerNight`.
- Rooms left is returned only by the price calendar, for the cheapest rate of each date.
- The calendar's points price is the first night's award price. For stays longer than one night, the average per night is in the room list.
- Award rates are the public award chart. Whether a member has enough points to redeem depends on their own account and isn't returned.
- A corporate or promotion code that doesn't cover the hotel's brand isn't rejected: Hilton returns its generic `LV0` rate, which can be dearer than sending no code. The run log warns you when that happens.
- Group codes and promotion codes couldn't be verified end to end. Corporate codes and special rates were.
- There's no hotel search here. You give hotels by code or URL, one or many per run.
- A stay must be between 1 and 30 nights.

### Feeding a rate monitor or your own code

The setup we'd suggest for a comp-set monitor: an Apify Schedule, empty dates so the rolling window applies, a price memory store and "Only new or changed". Each run then returns only the stays whose lowest rate moved, and a webhook or the Slack and Google Sheets integrations can pass them on. Zapier, Make, Airbyte and GitHub connect the same way.

From code, one call starts a run and returns the rows:

```
POST https://api.apify.com/v2/acts/boncross~hilton-room-rates/run-sync-get-dataset-items
```

There's an `apify-client` package on npm for Node.js and on PyPI for Python. An agent in Claude Desktop, Cursor or your own MCP client can call the actor through `mcp.apify.com` as `boncross/hilton-room-rates`: it sends hotels and dates and gets the priced rooms back as JSON.

### FAQ

#### Do I need proxies or a Hilton account?

No proxy, no proxy charge and no sign-in. These are the rates any visitor sees without logging in.

#### What is a Hilton hotel code?

It's the code Hilton gives each property, such as LONCWHI for Hilton London Canary Wharf or DXBGIGI for Hilton Garden Inn Dubai Deira. It appears as `ctyhocn` in hilton.com booking URLs, and you can paste those URLs in place of the code.

#### What do I get for a sold-out stay, and do I pay for it?

You get one row with `isSoldOut: true` and the dates, which is what a rate monitor needs to know. It costs the $0.0005 check fee, a seventh of the Free-plan price of a priced stay. A stay Hilton never answered is an error row and costs nothing.

#### How do I compare cash and points for the same room?

Choose both rate types. Each room comes back twice, once as a cash row and once as a points row that also has a cash rate and its plan name. Divide one by the other and you have the cash value of a point, room by room.

#### Why does an award stay show a different points cost for each night?

Hilton prices award nights by the night. A three-night stay can cost a different number of points on each of the three. You get the nightly figures as a list in `pointsNightly`, alongside the total for the stay.

#### Should I turn on every rate plan?

Only if you need the plans themselves. The default row per room is enough to track a hotel's prices, and it keeps your dataset small. Every rate plan costs the same per hotel-stay but returns 10 to 30 times the rows, capped at the 250 cheapest per stay.

#### How do I find the cheapest night in a month?

Turn on the monthly price calendar and set "Nights" to your stay length. Sort the rows by `pricePerNight`. Then price the dates you like with the calendar off to see each room.

#### My corporate code returned a dearer rate. Why?

The code probably doesn't cover that hotel's brand. Hilton doesn't reject it. It answers with its generic `LV0` rate, and the run log flags it.

#### Is it legal to scrape Hilton?

Scraping publicly available data is generally lawful. These are rates anyone can see without signing in, and no personal data is collected. You remain responsible for complying with Hilton's terms and the law that applies to you.

### More from BonCross

- [Hilton Hotel Details Scraper](https://apify.com/boncross/hilton-hotel-details): Everything a Hilton property publishes about itself: address, coordinates, phone,…
- [Hilton Hotel Search Scraper](https://apify.com/boncross/hilton-hotel-search): Every Hilton hotel for any destination and dates.
- [ikyu.com Room Rates Scraper (一休)](https://apify.com/boncross/ikyu-room-rates): Each room and rate plan ikyu.com (一休) sells for a hotel or ryokan on your dates.
- [ikyu.com Search Scraper (一休)](https://apify.com/boncross/ikyu-search): ikyu.com (一休) search results for any Japanese area, station or landmark on your dates.
- [Jalan.net Area Rates Scraper (じゃらん)](https://apify.com/boncross/jalan-area-rates): Jalan (じゃらん) prices and rooms left for every available hotel in an area, a whole…
- [Jalan.net Room Rates Scraper (じゃらん)](https://apify.com/boncross/jalan-room-rates): Every plan and room Jalan (じゃらん) lists for a hotel on a date.

### Your feedback

Seen a rate here that doesn't match Hilton's booking page, or a room that's missing from a stay? Send us the hotel code and dates on the Issues tab in Apify Console. We read every issue, and the awkward cases are the ones that improve the actor.

# Changelog

This Actor's version history is a separate document: https://apify.com/boncross/hilton-room-rates/changelog.md

# Actor input Schema

## `hotels` (type: `array`):

Hotel codes such as LONCWHI, or any hilton.com hotel or booking URL.

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

Hilton page addresses, with the option to load them in bulk from a file, a Google Sheet or a remote list. Use this when you have more links than you want to paste. Combined with anything in the list above.

## `maxRoomsPerHotel` (type: `integer`):

Cap the rooms returned for each hotel and stay, cheapest first; every rate plan of a kept room is returned. 0 returns every room.

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

Stop after this many priced hotel-stays across the run: one hotel, one stay, one rate mode, with all its rooms and rate plans. With the monthly price calendar, each priced date counts as one. 0 means no limit. Sold-out and unchanged stays are not counted.

## `maxRows` (type: `integer`):

Stop after this many rows (one per room and rate plan). The last hotel-stay is cut to fit, keeping its cheapest rates, and billed as one stay. 0 means no limit; the run stops at whichever cap it reaches first.

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

YYYY-MM-DD. Leave empty to use the days-ahead setting. Lowercase checkin also works.

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

YYYY-MM-DD. Leave empty to use the number of nights. Lowercase checkout also works.

## `checkInDaysAhead` (type: `integer`):

Used when no check-in date is given: how many days from today the stay starts.

## `nights` (type: `integer`):

Used when no check-out date is given.

## `stays` (type: `array`):

Price several date ranges in one run. Each item takes checkIn and checkOut. Overrides the single stay above.

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

Number of adults in each room.

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

How many rooms to price.

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

Ages of children sharing the room, for example \[7, 10].

## `rateModes` (type: `array`):

Cash returns money rates. Points returns Honors award nights. Choose both to get each room twice, once priced each way.

## `specialRate` (type: `string`):

Ask for a discounted rate category instead of the public one.

## `promoCode` (type: `string`):

A promotion code to price the stay with.

## `corporateId` (type: `string`):

A corporate account number to price the stay with.

## `groupCode` (type: `string`):

A group booking code to price the stay with.

## `includeUnavailable` (type: `boolean`):

Keep rooms the hotel lists but is not selling for these dates.

## `allRatePlans` (type: `boolean`):

Off (the default): one row per room, the lead rate Hilton shows first for it. On: one row for every rate plan each room sells under (flexible, advance purchase, breakfast included, member and special rates), each with its own price and terms, often 10 to 30 times as many rows. A stay keeps at most its 250 cheapest rates.

## `priceCalendar` (type: `boolean`):

Instead of the room grid, return one row per hotel and arrival date: the lowest nightly rate for a stay of your length starting that day, its rate plan and room type, rooms left at that rate, and with the points rate mode the lowest points price. The calendar starts at your check-in date and runs to the end of that month, then through each further month you ask for.

## `calendarMonths` (type: `integer`):

With the monthly price calendar: how many months to cover. The month of the check-in date counts as the first and is covered from the check-in date on. Each further month is covered in full.

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

Three-letter code such as USD or JPY. Default USD; clear it for the hotel's own currency.

## `priceStoreName` (type: `string`):

Name a store and the actor remembers the lowest rate for each hotel and stay, then reports the change on the next run.

## `onlyNewOrChanged` (type: `boolean`):

Skip a hotel and stay whose lowest rate has not moved since the last run. Needs a price memory store.

## `includeRawData` (type: `boolean`):

Add the untouched record from the site next to the parsed fields.

## `delayMs` (type: `integer`):

Optional pause before each call, in milliseconds. 0 (the default) runs as fast as the parallel limit allows. Values above 2000 are treated as 2000.

## `maxConcurrency` (type: `integer`):

How many requests run at once across the whole run. The default is the fastest level measured clean; lower it only if a run reports refusals or errors.

## Actor input object example

```json
{
  "hotels": [
    "LONCWHI",
    "HNLMOGV"
  ],
  "startUrls": [],
  "maxRoomsPerHotel": 0,
  "maxItems": 0,
  "maxRows": 0,
  "checkInDaysAhead": 30,
  "nights": 2,
  "adults": 2,
  "rooms": 1,
  "rateModes": [
    "cash"
  ],
  "specialRate": "",
  "includeUnavailable": false,
  "allRatePlans": false,
  "priceCalendar": false,
  "calendarMonths": 1,
  "currency": "USD",
  "onlyNewOrChanged": false,
  "includeRawData": false,
  "delayMs": 0,
  "maxConcurrency": 16
}
```

# Actor output Schema

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

Hilton room rates: every row the run returned.

## `stats` (type: `string`):

Counts for the run: what was resolved, fetched, filtered and returned.

# 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 = {
    "hotels": [
        "LONCWHI",
        "HNLMOGV"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/hilton-room-rates").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 = { "hotels": [
        "LONCWHI",
        "HNLMOGV",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("boncross/hilton-room-rates").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "hotels": [
    "LONCWHI",
    "HNLMOGV"
  ]
}' |
apify call boncross/hilton-room-rates --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,boncross/hilton-room-rates"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/90tBbIkt3RjysB1TU/builds/dPfNJnNgQGlqt8qxG/openapi.json