# Hotels.com Reviews Scraper 🏨 Ratings, Text & Sentiment (`factden/hotels-com-reviews-scraper`) Actor

Scrape Hotels.com hotel reviews at scale - guest ratings, full review text, sub-ratings, stay dates, traveler type, language & owner responses, plus LLM-ready markdown. Also accepts Expedia, Travelocity, Orbitz, Wotif, CheapTickets & ebookers URLs. Filter by date/rating; export JSON/CSV.

- **URL**: https://apify.com/factden/hotels-com-reviews-scraper.md
- **Developed by:** [Factden](https://apify.com/factden) (community)
- **Categories:** Travel, Automation, AI
- **Stats:** 8 total users, 7 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.002 / review

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

## Hotels.com Reviews Scraper

**Hotels.com Reviews Scraper** extracts every public **guest review** from [Hotels.com](https://www.hotels.com)
at scale — **ratings out of 10**, full **review text**, category **sub-ratings**, **stay dates**, **traveler
type**, **language**, and **hotel owner/management responses** — plus a per-review **LLM-ready markdown** block.
Export clean **CSV, JSON, Excel**, or pull it via **API**. No login, no Hotels.com API key, **pay per review with
no start fee**. Use it for **guest-feedback and sentiment analysis**, **hotel reputation monitoring**, competitor
benchmarking, or to build a **hotel-review dataset** for RAG / LLM pipelines.

> ⭐ **Found this useful?** Please **rate & bookmark** the actor — it helps other travelers and hotel teams find it.

> **One scraper, all seven Expedia Group hotel brands** — **Hotels.com, Expedia, Travelocity, Orbitz, Wotif,
> CheapTickets & ebookers.** They share one backend, so any brand's hotel URL returns the **same fields, same
> schema**. A single actor replaces seven separate review scrapers — something no single-site Hotels.com scraper
> can do.

Runs on the Apify platform: **scheduling**, a **REST API**, **webhooks & integrations**, **proxy rotation**, and
**run monitoring** out of the box — plus **incremental / since-date** runs so you only pull what's new.

![Hotels.com hotel reviews - one row per review](https://raw.githubusercontent.com/factden/apify-actor-assets/main/hotels-com-reviews-scraper/02-reviews-overview.png)

### What data can I extract from Hotels.com reviews?

Per review — one clean row, with the hotel context merged onto every row so each stands alone:

| Field | Description |
|---|---|
| `overallRating`, `ratingLabel` | Guest score on the **/10 scale** + label ("Exceptional", "Good", "Fair"…). |
| `reviewText`, `verified` | Full written review + verified-stay flag. |
| `subRatings` | Per-review category scores — cleanliness, service, room comfort, hotel condition, amenities, value. |
| `submittedAt`, `checkInDate`, `checkOutDate` | Submission date + stay dates. |
| `travelCompanions`, `travelerCategories` | Who they travelled as (Family, Couple, Business…). |
| `language`, `isMachineTranslated` | Original language + machine-translation flag. |
| `reviewPhotos`, `helpfulVotes`, `ownerResponse` | Guest photo URLs, helpful votes, hotel owner reply `{text, date, responder}`. |
| `brandType` | The brand the review was originally posted on (shown as **Review source**). |
| `markdownContent` | Self-contained **LLM-ready** markdown block for RAG / vector-DB ingestion. |

Alongside the reviews you get a **per-hotel aggregate**: average rating, recency-weighted rating, total review
count, the full 1–5 **rating distribution**, category sub-scores, traveler-type & language counts, and coordinates.

### Why use it? Hotels.com Reviews Scraper vs the alternatives

| | **This actor** | Official Hotels.com API | Manual copy-paste / DIY script |
|---|---|---|---|
| Hotels.com guest reviews | ✅ All, paginated | ❌ No public reviews API | ⚠️ A few, then blocked |
| Sub-ratings + /10 score + owner responses | ✅ | ❌ | ⚠️ Manual |
| LLM-ready markdown per review | ✅ | ❌ | ❌ |
| 6 sibling brands (Expedia, Travelocity…) | ✅ One input | ❌ | ❌ |
| Export CSV / JSON / Excel / API | ✅ | — | ⚠️ |
| Cost | **Pay per review, no start fee** | — | Engineering time + proxies |

- **Reputation monitoring & sentiment analysis** — track guest feedback for your own or competitor hotels; every
  review carries structured sub-ratings and a sentiment-ready text block.
- **Competitor benchmarking** — pull rating distributions, category sub-scores and review volume per property.
- **Market research & reviewer demographics** — analyze traveler types, languages, and what guests praise or
  complain about across a whole market.
- **AI / RAG pipelines & review datasets** — the `markdownContent` block is ready for vector-DB ingestion, so you
  can build a clean hotel-review dataset for an LLM with no post-processing.

### How to scrape Hotels.com reviews

1. Open a hotel on Hotels.com and copy its URL — it contains a `/ho<number>/` segment, e.g.
   `https://www.hotels.com/ho119566/bellagio-las-vegas-united-states-of-america/`.
2. Paste one or more such URLs, bare Hotels.com property IDs, or any Expedia Group brand URL into **Hotel URLs**.
3. (Optional) Set **Max reviews per hotel**, a **date range**, a **rating range**, a **sort order**, or **Review
   sources**.
4. Click **Start**, then **export to CSV, JSON, Excel**, or pull the results from the **API**.

![Input tab - hotel URLs plus filters & limits](https://raw.githubusercontent.com/factden/apify-actor-assets/main/hotels-com-reviews-scraper/01-input-form.png)

#### Input

| Field | Description |
|---|---|
| **Hotel URLs or property IDs** (`hotelUrls`) | Hotels.com `/ho<id>/` URLs, **bare Hotels.com IDs** (`242128`), or URLs from any of the 6 sibling brands. One per line. |
| **Max reviews per hotel** (`maxReviewsPerHotel`) | Cap per hotel (default 200). |
| **Sort reviews by** (`sortBy`) | `newest` (default), `oldest`, `highestRating`, `lowestRating`. |
| **From / To date** (`fromDate` / `toDate`) | Keep only reviews in a `YYYY-MM-DD` range — ideal for incremental monitoring. |
| **Min / Max rating** (`minRating` / `maxRating`) | Keep only reviews within a 1–5 rating range. |
| **Review sources** (`reviewSources`) | Which Expedia Group brands' reviews to return. Empty = all (cross-brand union). |
| **Proxy** (`proxyConfiguration`) | Datacenter is enough; residential for very large runs. |

### Output — export Hotels.com reviews to CSV, JSON & Excel

The actor writes **two datasets**: **Reviews** (default) — one row per guest review — and **Hotels** — one row
per hotel with the aggregate. The reviews dataset also exposes an **AI ingest** view (the LLM-ready
`markdownContent` column). Download any of them as **JSON, CSV, Excel or XML**, or fetch from the API.

The **Hotels** dataset gives you one aggregate row per property — average & recency-weighted rating, total review
count, rating distribution, category sub-scores, and coordinates:

![Hotels dataset - one aggregate row per hotel with average rating, rating distribution and category sub-scores](https://raw.githubusercontent.com/factden/apify-actor-assets/main/hotels-com-reviews-scraper/04-hotel-overview.png)

A **real review row** from a run on the Bellagio (Las Vegas), pasted as a Hotels.com URL:

```json
{
  "hotelId": 140596,
  "hotelName": "Bellagio",
  "hotelUrl": "https://www.hotels.com/ho119566/bellagio/",
  "source": "hotels",
  "reviewId": "6a5163ef5acf8d54499c0073",
  "submittedAt": "2026-07-10T21:29:04Z",
  "overallRating": 10,
  "ratingLabel": "Exceptional",
  "reviewText": "Great as usual!",
  "subRatings": ["Cleanliness: 10", "Service: 10", "Hotel condition: 8", "Amenities: 10"],
  "verified": true,
  "reviewerName": "Alexey",
  "checkInDate": "2026-07-05T00:00:00Z",
  "checkOutDate": "2026-07-10T00:00:00Z",
  "travelCompanions": ["Family"],
  "travelerCategories": ["Families"],
  "language": "en",
  "isMachineTranslated": false,
  "helpfulVotes": 0,
  "reviewPhotos": [],
  "ownerResponse": null,
  "brandType": "Hotels.com",
  "markdownContent": "# Bellagio review (Hotels.com)\n\n**Rating:** 10/10 ★★★★★\n**Travelling as:** Family\n**Sub-ratings:** Cleanliness: 10; Service: 10; Hotel condition: 8; Amenities: 10\n\n## Review\nGreat as usual!"
}
````

Ratings are on the **/10 scale** to match Hotels.com's public display (the source stores /5; we present ×2).

The **AI ingest (LLM-ready)** view surfaces the self-contained `markdownContent` column for every review — load it
straight into a vector database or LLM with no reshaping:

![Reviews AI ingest view - LLM-ready markdown column for each Hotels.com review](https://raw.githubusercontent.com/factden/apify-actor-assets/main/hotels-com-reviews-scraper/03-reviews-ai-ingest.png)

### How much does it cost to scrape Hotels.com reviews?

**Pay-per-event** with **no start fee** — you pay only for the reviews you actually get, and **nothing** if a run
returns zero reviews:

| Plan | Price per 1,000 reviews |
|---|---|
| Free | **$2.50** |
| Bronze | **$2.30** |
| Silver | **$2.15** |
| Gold+ | **$2.00** |

**Examples:** 500 reviews ≈ **$1.25** · 5,000 reviews ≈ **$12.50** (Free) / **$10.00** (Gold). Lower **Max reviews
per hotel** to cap spend; your first runs are covered by **Apify's free tier**. There is **no per-run start fee**.

### Works with all 7 Expedia Group brands

One engine, one output schema, seven sites — paste a **Hotels.com, Expedia, Travelocity, Orbitz, Wotif,
CheapTickets** or **ebookers** hotel URL and it just works. Hotels.com `/ho<id>/` links and bare IDs are resolved
automatically; the other brands carry the id in a `.h<id>.` path. Use **Review sources** to keep only certain
brands' reviews, or leave it empty for the cross-brand union.

### Other FactDen scrapers

Building a review-intelligence pipeline? Pair this with:

- **[Expedia Reviews Scraper](https://apify.com/factden/expedia-hotel-reviews-scraper)** — the same engine, Expedia-branded.
- **[Trip.com & Ctrip Reviews Scraper](https://apify.com/factden/ctrip-trip-reviews-scraper)** — hotel reviews across Trip.com / Ctrip.
- **[G2 Reviews Scraper](https://apify.com/factden/g2-reviews-scraper)** — B2B software reviews & battlecards.
- **[Indeed Jobs Scraper](https://apify.com/factden/indeed-jobs-scraper)** — job listings & company data.

### FAQ

#### How do I scrape Hotels.com reviews?

Copy a hotel's Hotels.com URL (it contains a `/ho<number>/` segment) or its numeric ID, paste it into **Hotel
URLs**, and click **Start**. The actor pulls every public guest review newest-first and returns one structured row
per review — rating, text, sub-ratings, stay dates and owner responses — which you export as CSV, JSON or Excel.
Set **Max reviews per hotel** and a **From date** to control volume and cost.

#### Does Hotels.com have a reviews API?

Hotels.com does not offer a public reviews API for guest reviews — the review data is only on the website. This
actor is the practical alternative: it collects the same public reviews and hotel-rating aggregates and delivers
them as structured JSON/CSV, so you get API-style access to Hotels.com review data without an official endpoint.

#### Is it legal to scrape Hotels.com reviews?

This actor collects only **publicly available** review content. You are responsible for complying with Hotels.com's
Terms of Service and applicable laws (including data-protection rules) when you use the data. It does not collect
private or personal account data. See Apify's guide on
[whether web scraping is legal](https://blog.apify.com/is-web-scraping-legal/).

#### What data fields does each review include?

Each review row includes the overall rating (out of 10), a rating label, the full review text, per-category
sub-ratings (cleanliness, service, room comfort, condition, amenities, value), stay dates, traveler type, language,
guest photos, helpful votes, any owner/management response, the originating brand, and a self-contained LLM-ready
`markdownContent` block. A separate hotel row adds the aggregate ratings, review count and rating distribution.

#### Can I use the Hotels.com Reviews Scraper with the Apify API?

Yes. Every run is fully API-accessible — start runs, pass input, and fetch the dataset programmatically. For a
one-shot call, POST to the actor's `run-sync-get-dataset-items` endpoint with your `hotelUrls` and
`maxReviewsPerHotel` and the reviews come back in the response. Append `?view=aiIngest` for the LLM-ready markdown
columns.

#### Can I use this actor through an MCP Server?

Yes. The actor works with the Apify MCP Server, so AI agents (Claude, and any MCP-compatible client) can discover
and run it as a tool and receive the structured review data directly. The input schema carries descriptions and
sane defaults so an agent can run it without hand-holding — useful for building hotel-review agents and RAG
pipelines.

#### Can I build a hotel-review dataset for sentiment analysis or a RAG pipeline?

Yes — this is a common use. Each of the 27 review fields is structured, and every row also ships a self-contained
`markdownContent` block, so you can export thousands of reviews as JSON or CSV and load them straight into a
vector database, a sentiment-analysis model, or an LLM/RAG pipeline with no post-processing. The per-hotel
aggregate (average rating, rating distribution, category sub-scores) gives you ready-made labels for training or
reputation dashboards. Use the **AI ingest** dataset view to pull just the LLM-ready columns.

#### Can I integrate it with Make, Zapier, n8n or Google Sheets?

Yes. Results push straight into **Google Sheets, Make, Zapier, n8n**, a **webhook**, or your own app via the Apify
API. **Schedule** the actor hourly or daily and combine it with a **From date** for continuous, incremental review
monitoring that only pays for new reviews.

#### How is this different from a TripAdvisor or Booking.com scraper?

This actor is purpose-built for the **Expedia Group** ecosystem — Hotels.com plus six sibling brands that share one
backend — so a single run covers reviews other single-site scrapers miss. It returns Hotels.com's granular
per-category sub-ratings, the /10 rating scale, owner responses, and an LLM-ready markdown block, billed per review
with no start fee.

### Changelog

- **2026-07-12** — Initial release. Hotels.com guest reviews + hotel aggregates across all 7 Expedia Group brands;
  `/ho<id>/` and bare-ID resolution; per-review pay-per-event pricing; LLM-ready `markdownContent` view.

***

⭐ **Find this useful?** **Bookmark** the actor and leave a **review** on its Apify Store page — it helps others
find it and tells us which features to build next. Found a bug or need a field we don't return? Open the **Issues**
tab on this actor's Apify page.

# Actor input Schema

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

Paste one hotel per line — a Hotels.com hotel page URL (any regional domain) or a bare Hotels.com property ID. Hotels.com `/ho<id>/` links and bare numeric IDs are resolved to the review feed automatically. Also accepts Expedia, Travelocity, Orbitz, Wotif, CheapTickets & ebookers URLs, which carry the id in the `.h<id>.` path. Examples: `https://www.hotels.com/ho119566/bellagio-las-vegas-united-states-of-america/`, an Expedia URL like `https://www.expedia.com/Las-Vegas-Hotels-The-Venetian-Resort-Las-Vegas.h1443.Hotel-Information`, or a bare id like `242128`.

## `maxReviewsPerHotel` (type: `integer`):

How many reviews to pull per hotel (fetched newest-first). Lower this to control cost and run time.

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

Output order of the returned reviews. Reviews are fetched newest-first from the source; `Highest rating` / `Lowest rating` reorder the retrieved set (not a global top-N across the whole hotel).

## `fromDate` (type: `string`):

Keep only reviews submitted on or after this day. Leave empty for no lower bound.

## `toDate` (type: `string`):

Keep only reviews submitted on or before this day. Leave empty for no upper bound.

## `minRating` (type: `integer`):

Keep only reviews with an overall rating at or above this value (1–5).

## `maxRating` (type: `integer`):

Keep only reviews with an overall rating at or below this value (1–5).

## `reviewSources` (type: `array`):

Which Expedia Group brands' reviews to return per hotel. **Leave empty for all brands** (the cross-brand union, e.g. Hotels.com + Expedia reviews for the same property). Pick one for a single-brand filter, or several for a subset.

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

Proxy settings. Datacenter proxies are sufficient for Hotels.com at typical volumes; switch to residential IPs for very large runs.

## Actor input object example

```json
{
  "hotelUrls": [
    "https://www.hotels.com/ho119566/bellagio-las-vegas-united-states-of-america/",
    "https://www.expedia.com/Las-Vegas-Hotels-The-Venetian-Resort-Las-Vegas.h1443.Hotel-Information",
    "242128"
  ],
  "maxReviewsPerHotel": 200,
  "sortBy": "newest",
  "minRating": 1,
  "maxRating": 5,
  "reviewSources": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

One row per guest review (hotel context merged onto each row) with ratings, full review text, category sub-ratings, stay dates, traveler type, language, owner responses and an LLM-ready markdownContent block.

## `hotels` (type: `string`):

One row per hotel with aggregate average rating, recency-weighted rating, total review count, category sub-ratings, coordinates and how many reviews were extracted.

# 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 = {
    "hotelUrls": [
        "https://www.hotels.com/ho119566/bellagio-las-vegas-united-states-of-america/",
        "https://www.expedia.com/Las-Vegas-Hotels-The-Venetian-Resort-Las-Vegas.h1443.Hotel-Information",
        "242128"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("factden/hotels-com-reviews-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 = { "hotelUrls": [
        "https://www.hotels.com/ho119566/bellagio-las-vegas-united-states-of-america/",
        "https://www.expedia.com/Las-Vegas-Hotels-The-Venetian-Resort-Las-Vegas.h1443.Hotel-Information",
        "242128",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("factden/hotels-com-reviews-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 '{
  "hotelUrls": [
    "https://www.hotels.com/ho119566/bellagio-las-vegas-united-states-of-america/",
    "https://www.expedia.com/Las-Vegas-Hotels-The-Venetian-Resort-Las-Vegas.h1443.Hotel-Information",
    "242128"
  ]
}' |
apify call factden/hotels-com-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hotels.com Reviews Scraper 🏨 Ratings, Text & Sentiment",
        "description": "Scrape Hotels.com hotel reviews at scale - guest ratings, full review text, sub-ratings, stay dates, traveler type, language & owner responses, plus LLM-ready markdown. Also accepts Expedia, Travelocity, Orbitz, Wotif, CheapTickets & ebookers URLs. Filter by date/rating; export JSON/CSV.",
        "version": "1.0",
        "x-build-id": "spZFcwZTcfjoSxaVo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/factden~hotels-com-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-factden-hotels-com-reviews-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/factden~hotels-com-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-factden-hotels-com-reviews-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/factden~hotels-com-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-factden-hotels-com-reviews-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",
                "required": [
                    "hotelUrls"
                ],
                "properties": {
                    "hotelUrls": {
                        "title": "🏨 Hotel URLs or property IDs",
                        "minItems": 1,
                        "maxItems": 500,
                        "type": "array",
                        "description": "Paste one hotel per line — a Hotels.com hotel page URL (any regional domain) or a bare Hotels.com property ID. Hotels.com `/ho<id>/` links and bare numeric IDs are resolved to the review feed automatically. Also accepts Expedia, Travelocity, Orbitz, Wotif, CheapTickets & ebookers URLs, which carry the id in the `.h<id>.` path. Examples: `https://www.hotels.com/ho119566/bellagio-las-vegas-united-states-of-america/`, an Expedia URL like `https://www.expedia.com/Las-Vegas-Hotels-The-Venetian-Resort-Las-Vegas.h1443.Hotel-Information`, or a bare id like `242128`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerHotel": {
                        "title": "🔢 Max reviews per hotel",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "How many reviews to pull per hotel (fetched newest-first). Lower this to control cost and run time.",
                        "default": 200
                    },
                    "sortBy": {
                        "title": "↕️ Sort reviews by",
                        "enum": [
                            "newest",
                            "oldest",
                            "highestRating",
                            "lowestRating"
                        ],
                        "type": "string",
                        "description": "Output order of the returned reviews. Reviews are fetched newest-first from the source; `Highest rating` / `Lowest rating` reorder the retrieved set (not a global top-N across the whole hotel).",
                        "default": "newest"
                    },
                    "fromDate": {
                        "title": "📅 Reviews from",
                        "type": "string",
                        "description": "Keep only reviews submitted on or after this day. Leave empty for no lower bound."
                    },
                    "toDate": {
                        "title": "📅 Reviews to",
                        "type": "string",
                        "description": "Keep only reviews submitted on or before this day. Leave empty for no upper bound."
                    },
                    "minRating": {
                        "title": "⭐ Minimum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Keep only reviews with an overall rating at or above this value (1–5).",
                        "default": 1
                    },
                    "maxRating": {
                        "title": "⭐ Maximum rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Keep only reviews with an overall rating at or below this value (1–5).",
                        "default": 5
                    },
                    "reviewSources": {
                        "title": "🏷️ Review sources (brands)",
                        "type": "array",
                        "description": "Which Expedia Group brands' reviews to return per hotel. **Leave empty for all brands** (the cross-brand union, e.g. Hotels.com + Expedia reviews for the same property). Pick one for a single-brand filter, or several for a subset.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "expedia",
                                "hotels",
                                "travelocity",
                                "orbitz",
                                "wotif",
                                "cheaptickets",
                                "ebookers"
                            ],
                            "enumTitles": [
                                "Expedia",
                                "Hotels.com",
                                "Travelocity",
                                "Orbitz",
                                "Wotif",
                                "CheapTickets",
                                "ebookers"
                            ]
                        },
                        "default": []
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Datacenter proxies are sufficient for Hotels.com at typical volumes; switch to residential IPs for very large runs.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```