# Marriott Room Rates Scraper (`boncross/marriott-room-rates`) Actor

Scrape every room and rate plan Marriott sells for a hotel and your dates. Just add hotel codes or marriott.com URLs and get stay total, nightly rate, mandatory fees, cancellation deadline, bed setup and rooms left, or Bonvoy points. $4.00 per 1,000 priced hotel-stays.

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

## Pricing

from $2.45 / 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

## Marriott Room Rates Scraper

### What is Marriott Room Rates Scraper?

A Marriott hotel sells far more rates than the first screen of its booking page suggests. Across six hotels measured on 15 September 2026, one stay held between 49 and 161 room and rate plan combinations, 120 on average. Marriott Room Rates Scraper returns all of them, priced, for any hotel in the Bonvoy portfolio, from Courtyard and Moxy to The Ritz-Carlton and St. Regis. You give it hotel codes or marriott.com links and your dates.

What you get here that a cheapest-rate scraper can't give you:

- The whole grid, billed by the stay. A hotel-stay costs $0.004 on the Free plan whether it returns 49 rows or 161.
- Cash or Bonvoy points. Switch the rate type to points and you get award nights, with points-plus-cash and upgrade options priced too.
- Totals you can compare. Each cash row has the nightly rate, the stay total with everything in, and how much of that total is tax and fees added on top.
- Speed at volume. 180 hotel-stays across 60 New York hotels finished in about 24 seconds.
- A sold-out hotel tells you so for $0.0005, and a stay that can't be priced at all costs nothing.

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

- 25 of 25 live checks on its inputs and filters passed on 8 October 2026
- 4 hotels run on 7 October 2026 on 2 stays each: 244 rates, none empty
- Charges matched the rows: 8 stays checked, 8 priced
- A stay that cannot be priced gets an uncharged row saying why

Also in each run:

- See the free-cancellation deadline, and whether a rate is prepaid and non-refundable
- Tell member, prepaid, package and standard rates apart by category and plan code
- Read room size, maximum occupancy and bed setup where the hotel publishes them
- Check rooms left and a near-sellout flag before a group booking
- Price several hotels over several date ranges at once
- Keep the lowest rate between runs and report how far it moved

Revenue managers use it to watch a competitive set and check parity against their other channels. Travel tools feed on the nightly rates and cancellation terms, and points collectors compare the cash price with the Bonvoy cost of the same night.

### What data is on each rate row?

| | |
|---|---|
| 🏨 Hotel MARSHA code and rate page link | 📅 Check-in, check-out and nights |
| 🛏 Room name, display name and bed setup | Room type code and room type name |
| 📐 Room size in m² and ft² | 👥 Maximum occupancy |
| Adults, rooms and child ages | Rate plan name and description |
| Rate plan code and rate plan type | Rate category (member, prepay, packages, standard) |
| Market code and source of rate | 💷 Nightly rate |
| 💰 Stay total | Subtotal before mandatory fees |
| Mandatory fees | Whether the room rate includes tax |
| Taxes and fees added on top | 💱 Currency |
| ⭐ Bonvoy points for award nights | Points saved and free nights |
| Points-plus-cash and upgrade pricing | 🚫 Free-cancellation deadline |
| Refundable or prepaid flag | Rooms left and rooms requested |
| Near-sellout flag | Members-only flag |
| 📉 Lowest rate for the stay and change since the last run | Rate plans offered for the stay |
| 🕒 Timestamp of the run | |

You get prices in the hotel's own currency, and each row names it.

### How much does it cost to scrape Marriott 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 Marriott answered, whatever the answer | $0.0005 | $0.0005 | $0.0005 | $0.0005 |
| `hotel-priced`, per hotel and stay that came back with rates, every rate plan included | $0.0035 | $0.00315 | $0.0028 | $0.00245 |

Enterprise plans pay the Business price.

That's **$4.00 per 1,000 priced hotel-stays** on the Free plan and $2.95 on Business, however many rate plans each stay returns. It's the whole price. There's no proxy to set up, and proxy and platform usage are included.

- One hotel, one stay: $0.002 + $0.0005 + $0.0035 = **$0.006** ($0.00495 on Business).
- Two hundred hotel-stays in one run: $0.002 + 200 × $0.004 = **$0.802** ($0.592 on Business). That's 0.4 cents a hotel-stay on the Free plan.

The $5 of credits that Apify's Free plan includes each month covers about 1,200 priced hotel-stays with this actor before you pay anything.

You pay the full $0.004 ($0.00295 on Business) only when a hotel-stay returns rates. The other outcomes:

- **Sold out for your dates.** You get one row that says so, and pay the $0.0005 check fee alone.
- **Nothing moved.** With "Only new or changed" on, a hotel-stay whose lowest rate is the same as last time returns no row and costs the $0.0005 check fee.
- **Couldn't be priced at all.** You get an error row and pay nothing for that stay.

### How to scrape Marriott room rates

You don't need to write code. It's a form in, a spreadsheet out.

1. [Create a free Apify account](https://console.apify.com/sign-up) and open [Marriott Room Rates Scraper](https://apify.com/boncross/marriott-room-rates).
2. Add your hotels as MARSHA codes such as NYCMQ, or paste marriott.com links.
3. Set check-in and check-out, guests and rooms. Leave the dates empty and it prices two nights starting 30 days from today.
4. Click Start. A single hotel-stay takes a few seconds.
5. Download the rates as Excel, CSV, JSON, XML or HTML.

### ⬇️ Input

Start with the hotels. A MARSHA code is the five-letter code Marriott gives each property (NYCMQ is the New York Marriott Marquis), and any marriott.com link that includes `propertyCode` works in its place. Got a long list of links? Load it under Start URLs from a file, a Google Sheet or a remote list. The two inputs are combined.

Dates can be fixed, or you can set "Days ahead" (default 30) and "Nights" (default 2) and let a scheduled run keep the stay the same distance out. "Extra stays" prices several date ranges in one run and replaces the single stay. Guests default to 2 adults in 1 room, and "Child ages" adds children.

"Rate types" decides which rates you get: `all` (the default, every public cash rate), `standard`, `prepay`, `packages`, `member`, `regular`, or `points` for award nights. Rooms the hotel lists with no availability are left out.

You have three limits, and each defaults to 0, which means no limit. "Maximum rate plans per hotel-stay" trims each grid (up to 500). "Maximum hotel-stays for the whole run" counts priced stays, and "Maximum rows for the whole run" counts rows. The run stops at whichever of those two it reaches first, and you're not charged for anything past a cap.

**One hotel, one stay**

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

**Several hotels across two date ranges**

```json
{
  "hotels": ["NYCMQ", "EDIWH", "DPSSM"],
  "stays": [
    { "checkIn": "2026-11-10", "checkOut": "2026-11-12" },
    { "checkIn": "2026-12-05", "checkOut": "2026-12-07" }
  ],
  "adults": 2
}
```

**Award nights in points**

```json
{
  "hotels": ["NYCMQ"],
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-12",
  "rateModes": ["points"]
}
```

**A daily watch that reports only when the lowest rate moves**

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

#### For developers

- `maxRatePlansPerHotel` caps the rate plans kept for each hotel-stay. `maxItems` caps the priced hotel-stays in the run and `maxRows` caps the rows.
- When `maxRows` falls partway through a stay, that stay is cut to fit, keeping its cheapest rates, and billed as one stay. Sold-out and unchanged stays don't count towards `maxItems`.
- `stays` overrides `checkIn`, `checkOut`, `checkInDaysAhead` and `nights`. A stay must be 1 to 30 nights.
- `includeRoomDetails` (on by default) adds each room type's size, maximum occupancy and Marriott's name for it.
- `priceStoreName` names the store that remembers each hotel-stay's lowest rate. `onlyNewOrChanged` then returns rows only where it moved. The first run has nothing to compare with.
- `maxConcurrency` (default 16, 1 to 32) is how many hotel-stays are priced at once. `delayMs` (default 0, up to 10,000) adds a pause before each request. We'd leave both alone.
- Rows arrive in the order of your hotels and stays, even though stays are priced side by side.
- If the platform restarts a run, it carries on where it stopped without repeating or re-billing a stay.
- Identical rate plans that Marriott lists twice for the same room are returned once.
- `includeRawData` adds the untouched record to each row under `raw`.

### ⬆️ Output

You get one row per room and rate plan combination. The Overview view in the Output tab shows hotel, dates, room, rate plan, prices, cancellation deadline and rooms left as a table.

```json
{
  "id": "NYCMQ-REGB-DBDB-2026-11-10-2026-11-12",
  "hotelId": "NYCMQ",
  "url": "https://www.marriott.com/reservation/rateListMenu.mi?propertyCode=NYCMQ&fromDate=11/10/2026&toDate=11/12/2026&numberOfRooms=1&numAdultsPerRoom=2&flexibleDateSearch=false",
  "input": "NYCMQ",
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-12",
  "nights": 2,
  "adults": 2,
  "rooms": 1,
  "childrenAges": [],
  "roomName": "Deluxe",
  "roomDisplayName": "Deluxe",
  "roomDescription": "Guest room, 2 Double",
  "roomTypeCode": "dbdb",
  "roomTypeName": "Deluxe",
  "bedConfiguration": "Guest room, 2 Double",
  "roomSizeSqm": 35,
  "roomSizeSqft": 392,
  "roomSizeText": "392sqft/35sqm",
  "maxOccupancy": 4,
  "ratePlanName": "Flexible Rate",
  "ratePlanCode": "REGB",
  "ratePlanType": "24.RPT",
  "marketCode": "12REGB",
  "rateCategory": "StandardRates",
  "sourceOfRate": "MARSHA",
  "isMembersOnly": false,
  "currency": "USD",
  "pricePerNight": 694,
  "priceTotal": 1703.01,
  "priceTotalExcludingFees": 1388,
  "mandatoryFees": 90,
  "pricesIncludeTax": false,
  "taxesAndChargesExcluded": 315.01,
  "points": null,
  "pointsSaved": null,
  "freeNights": null,
  "freeCancellationUntil": "2026-11-07T00:00:00Z",
  "isRefundable": true,
  "isDepositRequired": false,
  "roomsLeft": null,
  "roomsRequested": null,
  "isNearSellout": false,
  "lowestPerNight": 510,
  "lowestTotal": 1280.72,
  "ratePlanCount": 102,
  "previousLowestPerNight": null,
  "priceChange": null,
  "priceChangePct": null,
  "scrapedAt": "2026-10-07T19:28:47.501Z"
}
```

**Reading the prices.** `pricePerNight` is the average nightly room rate, and `priceTotalExcludingFees` is that rate for the whole stay. `priceTotal` is the stay total with taxes and charges in. On the row above, 2 × 694 = 1,388 before taxes and fees and 1,703.01 all in.

`pricesIncludeTax` tells you whether the room rate (`pricePerNight`, `priceTotalExcludingFees`) already has tax inside it. It's `false` where Marriott adds a tax on top, as in the United States, Singapore and Japan, or with a city tax in Paris and Berlin. It's `true` where nothing is added, as in the United Kingdom, where VAT is inside the rate. `priceTotal` always includes everything.

`taxesAndChargesExcluded` is what `priceTotal` adds to the room rate for the whole stay, taxes and mandatory fees together: `priceTotal` = rooms × `priceTotalExcludingFees` + `taxesAndChargesExcluded`. With more than one room, `priceTotal` covers all the rooms while `priceTotalExcludingFees` and `mandatoryFees` are per room. If you're comparing hotels, compare `priceTotal`. Don't multiply out the nightly rate.

`ratePlanCount` is how many rate plans the hotel offered for the stay, before any cap.

Other columns on each row:

| Field | What it is |
|---|---|
| `parentRoomType` | The hotel's four-letter room type when `roomTypeCode` holds a product code instead; null on most hotels. |
| `roomAttributes` · `roomAttributesByCategory` | The room's listed attributes (such as bedding and accessibility features), as one list and grouped by Marriott's category. Empty for most rooms, which list none. |
| `isAccessible` | `true` when one of the room's attributes describes an accessible room (mobility, hearing, roll-in shower); null otherwise, never `false`. |
| `ratePlanDescription` | Marriott's description of the rate plan and its terms; null where it gives none. |
| `rateCategoryValue` | A second label for the rate category, beside `rateCategory`; null on every row measured. |
| `isRestrictedRate` | Whether Marriott marks the rate as restricted to guests who qualify for it; null where it says nothing. |
| `cashAndPointsCash` | On a Cash + Points rate, the cash part paid beside `points`; null otherwise. |
| `upgradePoints` · `upgradeCash` | On a points-plus-cash upgrade rate, the points and the cash it costs; null otherwise. |
| `isRepresentativeRoom` | Marriott's flag for the room it shows as representative of the hotel; null where it says nothing. |
| `previousScrapedAt` | With **Price memory store** set, when the previous lowest price (`previousLowestPerNight`) was seen; null on a first run. |

A hotel that's sold out for your dates returns one row with `isSoldOut: true` and no room or price. A hotel code that can't be read, or a stay that couldn't be priced, returns a row with `error` filled in.

### How big is a grid, and how fast is a run?

One hotel-stay returned 49 to 161 rows across the six hotels measured, which is why the rate-plan and row caps exist.

| Run | Rows | Run time |
|---|---:|---:|
| Six hotels in four cities, three stays each, full grid | 974 | 6.0 to 7.8 s |
| Six hotels in four cities, three stays each, full grid (2 October) | 1,459 | 6.7 to 7.0 s |
| Six hotels, six stays each, full grid | 2,015 | 8.3 s |
| 60 New York hotels × 3 stays, 10 rate plans kept per stay | 1,739 | about 24 s |

These are whole runs on Apify, measured on 1 and 2 October 2026. The last one is 180 hotel-stays, a pace of roughly 450 a minute, and many thousands fit inside the default one-hour run limit.

Marriott prices one hotel at a time, which means a run grows with hotels multiplied by stays. Up to 16 hotel-stays are priced side by side.

### FAQ

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

Neither. There's no proxy to set up and no proxy charge, and the rates are the ones Marriott shows without a sign-in.

#### What is a MARSHA code, and where do I find one?

It's the five-letter code Marriott gives each hotel, such as NYCMQ for the New York Marriott Marquis or EDIWH for W Edinburgh. You'll see it as `propertyCode` in marriott.com reservation links, and you can paste those links in place of the code. [Marriott Hotel Search Scraper](https://apify.com/boncross/marriott-hotel-search) returns the code for every hotel in a destination.

#### How do I get cash rates and points for the same stay?

Run it twice. A run returns cash rates or award nights depending on the rate types you choose. With `points`, rows come back with the points cost, points saved and free nights, including points-plus-cash upgrades.

#### What does a sold-out hotel return, and what does it cost?

One row with `isSoldOut: true` and no rates, for the $0.0005 check fee. You still learn that the hotel has nothing for those dates, which a rate monitor needs to know.

#### Why is the stay total higher than nights times the nightly rate?

Because Marriott adds tax and fees on top of the room rate in many countries. `priceTotal` has them in, `pricePerNight` doesn't unless `pricesIncludeTax` is true, and `taxesAndChargesExcluded` is the difference for the stay.

#### How do I watch a hotel and hear only when the rate moves?

Schedule the run, give "Price memory store" a name and switch on "Only new or changed". Use "Days ahead" so the stay stays the same distance out. From the second run on you get a row only when the lowest rate has moved, with the previous rate and the change beside it.

#### Can I use a corporate or promotional code?

Not with this actor. You get the public rates any visitor sees. Corporate codes, negotiated rates and promotional codes aren't supported.

#### Why are room size and occupancy empty for some hotels?

They're filled only where the hotel publishes them. On 5 October 2026 every row at W Edinburgh and New York Marriott Marquis had an occupancy, 77 of 89 at London Marriott Grosvenor Square, and none at Yokohama Bay Sheraton, which gives a room type name only. Where a hotel gives a size range ("25sqm/269sqft-32sqm/344sqft") or no size, `roomSizeSqm` and `roomSizeSqft` are empty and `roomSizeText` keeps the hotel's wording.

#### What are the limits?

- Rows identify the hotel by MARSHA code. The hotel's name isn't on a rate row.
- Taxes aren't itemised by kind. You can see whether tax is added on top of the room rate and how much is added in total on each cash row. A tax already inside the rate (such as UK VAT) isn't broken out, and the split between sales tax and city tax isn't published.
- Fill rates vary by hotel. On a 456-row sample the cancellation deadline was on 76% of rows, rooms left on 43% and a rate plan description on 67%.
- Room attribute lists are present for some rooms only, roughly one row in twelve.
- A stay must be between 1 and 30 nights.
- The first run of a price watch has no previous rate, and `priceChange` is empty on it.
- Rates are read live when the run happens. Marriott can change one before you book.

#### Is it legal to scrape Marriott?

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

### Schedule it, or call it from code

A daily rate watch is an Apify Schedule plus the price memory inputs above. A webhook can fire when a run finishes, and Apify's integrations pass the rows to Google Sheets, Slack, Zapier, Make or Airbyte.

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

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

There's an `apify-client` package on npm for Node.js and on PyPI for Python. For AI agents, the actor is callable at `mcp.apify.com` as `boncross/marriott-room-rates`, which lets an agent price a hotel's rate grid as a tool call.

### More from BonCross

- [Marriott Hotel Details Scraper](https://apify.com/boncross/marriott-hotel-details): Everything a Marriott property publishes: address, coordinates, phones, brand, guest…
- [Marriott Hotel Search Scraper](https://apify.com/boncross/marriott-hotel-search): Every Marriott hotel for a destination and dates.
- [Rakuten Travel Room Rates Scraper (楽天トラベル)](https://apify.com/boncross/rakuten-travel-room-rates): Every plan and room Rakuten Travel (楽天トラベル) prices for a hotel and your dates.
- [Rakuten Travel Search Scraper (楽天トラベル)](https://apify.com/boncross/rakuten-travel-search): Rakuten Travel (楽天トラベル) hotel search results for any area and your dates.
- [Trip.com Hotel Details Scraper](https://apify.com/boncross/tripcom-hotel-details): The full Trip.com record for any hotel, with its guest reviews.
- [Trip.com Hotel Search Scraper](https://apify.com/boncross/tripcom-hotel-search): Every hotel Trip.com lists for a destination and your dates.

### Your feedback

Seen a rate that doesn't match Marriott's page, or a hotel code that won't price? Tell us on the Issues tab in Apify Console, with the hotel code and dates if you can. We read every issue and reply there.

# Changelog

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

# Actor input Schema

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

Marriott hotel codes (the five letters in the hotel's marriott.com address, such as NYCMQ) or marriott.com URLs containing propertyCode.

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

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

## `maxRatePlansPerHotel` (type: `integer`):

Cap the rows returned for each hotel and stay. 0 returns every rate plan.

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

Stop after this many priced hotel-stays across the run: one hotel and one stay, with all its rooms and rate plans. 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`):

Which rate types to ask for. Leave as all for every public cash rate in one pass, or choose points for award nights.

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

Add each room type's size (square metres and square feet), maximum occupancy and Marriott's name for the room type, read once per hotel. Turn off to skip that read.

## `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": [
    "NYCMQ",
    "EDIWH"
  ],
  "startUrls": [],
  "maxRatePlansPerHotel": 0,
  "maxItems": 0,
  "maxRows": 0,
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-12",
  "checkInDaysAhead": 30,
  "nights": 2,
  "adults": 2,
  "rooms": 1,
  "rateModes": [
    "all"
  ],
  "includeRoomDetails": true,
  "onlyNewOrChanged": false,
  "includeRawData": false,
  "delayMs": 0,
  "maxConcurrency": 16
}
```

# Actor output Schema

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

Marriott 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": [
        "NYCMQ",
        "EDIWH"
    ],
    "checkIn": "2026-11-10",
    "checkOut": "2026-11-12"
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/marriott-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": [
        "NYCMQ",
        "EDIWH",
    ],
    "checkIn": "2026-11-10",
    "checkOut": "2026-11-12",
}

# Run the Actor and wait for it to finish
run = client.actor("boncross/marriott-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": [
    "NYCMQ",
    "EDIWH"
  ],
  "checkIn": "2026-11-10",
  "checkOut": "2026-11-12"
}' |
apify call boncross/marriott-room-rates --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,boncross/marriott-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/HU6NmVO86joSYeYjC/builds/n4ucBPgS8AOQHYrFo/openapi.json