# HRS Hotel Reviews Scraper (`automation-lab/hrs-hotel-reviews-scraper`) Actor

Extract public HRS guest reviews, comments, category ratings, traveler segments, and hotel summaries by hotel URL or ID. Fast HTTP output for reputation monitoring.

- **URL**: https://apify.com/automation-lab/hrs-hotel-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.14 / 1,000 guest reviews

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## HRS Hotel Reviews Scraper

Collect current public HRS guest reviews and hotel rating summaries without a login.

Use **HRS Hotel Reviews Scraper** to turn HRS hotel URLs or numeric hotel IDs into structured review data for reputation monitoring, service-quality analysis, and competitor benchmarking.

The Actor uses fast HTTP requests rather than a browser by default.
It separates review records from hotel-level summaries so analysts can export each entity cleanly.

### What does HRS Hotel Reviews Scraper do?

The Actor visits public HRS hotel detail pages and extracts the review data that HRS currently exposes there.

For each hotel, it can return:

- 🗣️ current public guest-review records
- 👤 reviewer name and traveler type
- 📅 review timestamp and locale
- 💬 positive, negative, and combined review text
- ⭐ overall review score
- 👍 recommendation signal
- 📊 category-level scores such as cleanliness and value for money
- 🏨 aggregate hotel score and lifetime review count
- 👥 traveler-segment averages and recommendation ratios
- 🔗 canonical HRS source URL and scrape timestamp

HRS can show a lifetime aggregate count larger than the number of review records embedded on the current page.
The Actor reports both values honestly and never invents unavailable historical records.

### Who is it for?

#### Hotel groups

Monitor your properties and compare service categories across locations.

#### Reputation-management agencies

Schedule recurring collection and send normalized comments into sentiment or alerting workflows.

#### Travel-market analysts

Compare aggregate scores, recommendation ratios, and traveler segments across a hotel set.

#### Hospitality data teams

Feed typed HRS review records into warehouses, dashboards, notebooks, or language models.

#### Competitor-intelligence teams

Track visible rating changes for a stable list of competing properties.

### Why use this HRS reviews extractor?

Manual copying is slow and loses structured context.
This Actor preserves the relationship between a comment, its reviewer, its rating categories, and its hotel.

Key benefits include:

- ⚡ HTTP-first collection with low compute requirements
- 🔁 repeatable inputs for scheduled monitoring
- 🧹 normalized JSON fields across hotels
- 📦 separate `reviews` and `summaries` datasets
- 🎯 inclusive date filtering for incremental jobs
- 🧩 direct integrations with Apify API, webhooks, Make, Zapier, and MCP
- 🛡️ fail-closed behavior when useful rating data disappears

### What HRS URLs are supported?

Use public hotel detail URLs containing a numeric hotel ID.

```text
https://www.hrs.com/en/hotel/391864
https://www.hrs.de/de/hotel/391864
````

You can also provide the ID directly:

```json
{
  "hotelIds": ["391864"]
}
```

Locale variants are normalized to the canonical English HRS detail URL for consistent parsing.
Search-result pages, booking URLs, and non-HRS URLs are rejected rather than guessed.

### Input

| Field | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | example hotel | Public HRS hotel detail URLs |
| `hotelIds` | array | `[]` | Numeric HRS hotel IDs |
| `maxReviewsPerHotel` | integer | `20` | Maximum currently exposed review records saved per hotel |
| `cutoffDate` | string | none | Keep reviews on or after `YYYY-MM-DD` |
| `alwaysReturnSummary` | boolean | `true` | Save a summary even when no review passes the cutoff |
| `proxyConfiguration` | object | none | Optional Apify Proxy settings for rate-limited batches |

Provide at least one URL or hotel ID.
Duplicate IDs are fetched only once per run.

### Quick-start input

```json
{
  "startUrls": [
    { "url": "https://www.hrs.com/en/hotel/391864" }
  ],
  "maxReviewsPerHotel": 20,
  "alwaysReturnSummary": true
}
```

This low-cost input is also suitable for testing an integration.

### Incremental monitoring input

Use `cutoffDate` when a scheduled workflow only needs recent reviews.
The boundary is inclusive.

```json
{
  "hotelIds": ["391864"],
  "cutoffDate": "2026-05-01",
  "maxReviewsPerHotel": 100,
  "alwaysReturnSummary": true
}
```

If no current record meets the cutoff, the summary still provides aggregate rating evidence when `alwaysReturnSummary` is enabled.

### Multiple-hotel input

```json
{
  "startUrls": [
    { "url": "https://www.hrs.com/en/hotel/391864" }
  ],
  "hotelIds": ["64820", "65907"],
  "maxReviewsPerHotel": 20
}
```

Hotels are processed conservatively and sequentially to reduce pressure on HRS.
One invalid hotel does not discard valid output from other hotels.
The run fails when every requested hotel fails extraction.

### Review output fields

The default dataset contains one row per current public review.

| Field | Description |
|---|---|
| `hotelId` | Numeric HRS hotel identifier |
| `hotelName` | Hotel name shown by HRS |
| `reviewerName` | Display name or `Anonymous` |
| `postedAt` | ISO review timestamp |
| `travelerType` | HRS traveler segment, such as `BUSINESS` |
| `locale` | Review locale supplied by HRS |
| `positiveComment` | Positive guest or hotel comment |
| `negativeComment` | Negative guest or hotel comment |
| `reviewText` | Combined non-empty comment text |
| `overallScore` | Review score on HRS's 10-point scale |
| `recommended` | Whether the reviewer recommends the hotel |
| `categoryRatings` | Named per-review category scores |
| `sourceUrl` | Canonical public hotel page |
| `scrapedAt` | ISO extraction timestamp |

### Hotel summary output fields

The `summaries` dataset contains one row per hotel.

| Field | Description |
|---|---|
| `hotelId` | Numeric HRS hotel identifier |
| `hotelName` | Hotel name |
| `aggregateScore` | Current aggregate score |
| `aggregateReviewCount` | Lifetime count displayed by HRS |
| `recommendationRatio` | Overall percentage recommending the hotel |
| `categoryAverages` | Hotel-wide category averages |
| `travelerSegments` | Segment score and recommendation objects |
| `reviewsAvailableOnPage` | Number of current review records embedded by HRS |
| `sourceUrl` | Canonical public source |
| `scrapedAt` | ISO extraction timestamp |

### Example review record

```json
{
  "hotelId": "391864",
  "hotelName": "Hotel Brandenburger Tor Potsdam",
  "reviewerName": "Jürgen B.",
  "postedAt": "2026-05-29T11:14:44.207Z",
  "travelerType": "BUSINESS",
  "locale": "en",
  "positiveComment": "Die zentrale Lage ist nahezu perfekt.",
  "negativeComment": "",
  "reviewText": "Die zentrale Lage ist nahezu perfekt.",
  "overallScore": 8.4,
  "recommended": true,
  "categoryRatings": {
    "hotelTidiness": 9,
    "pricePerformanceRatio": 8
  },
  "sourceUrl": "https://www.hrs.com/en/hotel/391864",
  "scrapedAt": "2026-07-24T06:24:46.171Z"
}
```

### Example hotel summary

```json
{
  "hotelId": "391864",
  "hotelName": "Hotel Brandenburger Tor Potsdam",
  "aggregateScore": 9.1,
  "aggregateReviewCount": 70,
  "recommendationRatio": 95.7,
  "categoryAverages": {
    "hotelTidiness": 9,
    "pricePerformanceRatio": 8.7
  },
  "travelerSegments": [
    {
      "travelerType": "BUSINESS",
      "averageScore": 9,
      "recommendationRatio": 92.7
    }
  ],
  "reviewsAvailableOnPage": 2,
  "sourceUrl": "https://www.hrs.com/en/hotel/391864"
}
```

### How much does it cost to scrape HRS hotel reviews?

The provisional BRONZE-tier price is:

- **$0.005 per run start**
- **$0.00022859 per review record**
- **$0.00045718 per hotel summary**

Higher Apify subscription tiers receive lower per-event rates.
You are charged for records actually saved, not the larger lifetime aggregate count shown by HRS.
A one-hotel page exposing two reviews and one summary therefore uses three output events plus the start event.
Always check the live pricing panel for the applicable tier price.

### Scheduling a reputation monitor

1. Create an Apify Task with stable HRS hotel IDs.
2. Set a modest `maxReviewsPerHotel`.
3. Add a daily or weekly schedule.
4. Store the last successful date in your downstream system.
5. Update `cutoffDate` for incremental collection, or deduplicate by hotel ID plus review timestamp.
6. Send the dataset webhook to your warehouse or alerting service.

A summary row is useful for detecting aggregate-score movement even when no new visible comment appears.

### Data-quality tips

- Use hotel IDs as stable join keys; names can change.
- Preserve `sourceUrl` for audit trails.
- Interpret category score `0` as unavailable; the Actor omits unavailable aggregate categories.
- Use `reviewsAvailableOnPage` to distinguish current records from `aggregateReviewCount`.
- Treat traveler segments with no score and no recommendation ratio as unavailable; the Actor omits them.
- Schedule conservatively instead of repeatedly fetching the same hotel every few minutes.
- Test date cutoffs against UTC ISO timestamps in review output.

### Integrations

#### Google Sheets

Export either dataset as CSV or connect an Apify dataset integration for a lightweight reputation tracker.

#### BigQuery or Snowflake

Load reviews as event-like rows and summaries as a hotel snapshot table keyed by `hotelId` and `scrapedAt`.

#### Make and Zapier

Trigger the Actor from a workflow, wait for completion, and route low scores or negative comments to an operations channel.

#### Slack or email alerts

Filter new review records by `overallScore`, `recommended`, or keywords before sending notifications.

#### Language-model workflows

Feed `reviewText`, traveler type, and category ratings into sentiment, topic, or root-cause classification prompts.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/hrs-hotel-reviews-scraper').call({
  hotelIds: ['391864'],
  maxReviewsPerHotel: 20,
  alwaysReturnSummary: true,
});

console.log(run.status, run.datasetId);
```

Named dataset links are available in the Actor run's storage metadata.
Use the `default` reviews dataset and the `summaries` alias rather than assuming both entity types share one table.

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/hrs-hotel-reviews-scraper').call(run_input={
    'hotelIds': ['391864'],
    'maxReviewsPerHotel': 20,
    'alwaysReturnSummary': True,
})
print(run['status'])
```

### cURL API example

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/automation-lab~hrs-hotel-reviews-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "hotelIds": ["391864"],
    "maxReviewsPerHotel": 20,
    "alwaysReturnSummary": true
  }'
```

Do not commit an Apify token to source control.
Use environment secrets in production automation.

### Use with Apify MCP

Connect AI clients through `https://mcp.apify.com?tools=automation-lab/hrs-hotel-reviews-scraper`.

#### Claude Code

```bash
claude mcp add --transport http apify https://mcp.apify.com?tools=automation-lab/hrs-hotel-reviews-scraper
```

#### Claude Desktop, Cursor, and VS Code

Use the following MCP JSON in Claude Desktop, Cursor, or VS Code, then authorize your Apify account:

```json
{
  "mcpServers": {
    "apify-hrs-reviews": {
      "url": "https://mcp.apify.com?tools=automation-lab/hrs-hotel-reviews-scraper"
    }
  }
}
```

Example prompts:

- “Run the HRS hotel reviews scraper for hotel 391864 and summarize recurring service themes.”
- “Compare HRS category averages and recommendation ratios for these hotel IDs.”
- “Collect visible HRS reviews posted since the first day of this month.”

Start with one hotel before scaling a new MCP workflow.

### Proxy behavior

Direct HTTP is the default because HRS currently serves useful anonymous server-rendered data.
No proxy is required for ordinary small runs.

If HRS rate-limits a larger batch, configure Apify Proxy in the advanced input section.
The Actor reuses a hotel-specific proxy session URL and limits request retries.
A proxy cannot make an invalid hotel ID valid, and malformed inputs fail before network work begins.

### Reliability and error handling

The Actor checks for HTTP success and useful HRS rating evidence.
It does not mark challenge pages or empty HTML as successful extraction.

Invalid URL scopes are rejected.
Malformed cutoff dates are rejected.
Individual hotel failures are logged while valid hotels continue.
If every requested hotel fails, the run exits non-zero so schedules and integrations can alert correctly.

### Legal and ethical use

This Actor extracts data visible on public HRS hotel pages without authentication.
Public availability does not remove your responsibility to follow applicable law, contractual terms, privacy requirements, and reasonable request rates.

Do not use the Actor to identify, harass, or profile individual reviewers.
Avoid combining review data with sensitive personal information.
Store only what your workflow needs and apply an appropriate retention policy.

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by HRS.

### FAQ

#### Does it scrape every historical HRS review?

No.
It saves review records that HRS currently embeds on the public hotel page and separately reports HRS's displayed lifetime aggregate count.

#### Why is `aggregateReviewCount` larger than `reviewsAvailableOnPage`?

The first is HRS's lifetime count; the second is the current set of detailed records publicly embedded in the fetched page.
This is expected source behavior.

#### Can I use only a hotel ID?

Yes.
Add numeric strings or numbers to `hotelIds`.

#### Is a proxy required?

Not for the normal public route.
Use optional proxy configuration only if your batch receives rate limiting.

#### Why did my cutoff return no review rows?

No currently exposed review may be on or after the selected date.
Keep `alwaysReturnSummary` enabled if you still need hotel-level evidence.

#### Why did the run fail with “No HRS hotel could be extracted”?

Check that each value is a numeric HRS hotel ID or a detail URL containing `/hotel/<id>`.
Also inspect logs for an HTTP block or a hotel page that no longer exposes rating data.

#### Can I combine URLs and IDs?

Yes.
Duplicates resolve to one hotel request.

#### What score scale does HRS use?

HRS review and aggregate scores are represented on a 10-point scale on the source pages currently supported.

### Related travel and review scrapers

Explore other Automation Lab Actors for adjacent workflows:

- [Booking Reviews Scraper](https://apify.com/automation-lab/booking-reviews-scraper)
- [Tripadvisor Reviews Scraper](https://apify.com/automation-lab/tripadvisor-reviews-scraper)
- [Google Maps Reviews Scraper](https://apify.com/automation-lab/google-maps-reviews-scraper)

Choose an HRS-specific Actor when HRS hotel IDs, HRS traveler segments, and HRS category ratings are required.
Use a broader travel Actor when your workflow starts from destinations or search-result discovery rather than known HRS hotel pages.

### Support

When reporting a problem, include:

- the public HRS hotel URL or ID
- the run ID
- the approximate run time
- whether a proxy was enabled
- the expected and observed dataset alias

Do not include private credentials or unrelated personal data.
A reproducible public hotel URL helps distinguish a source change from an input problem.

# Actor input Schema

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

Public HRS hotel detail URLs such as https://www.hrs.com/en/hotel/391864.

## `hotelIds` (type: `array`):

Numeric HRS hotel IDs. You can combine these with hotel URLs.

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

Maximum current public review records saved from each page. HRS may expose fewer records.

## `cutoffDate` (type: `string`):

Optional inclusive cutoff date in YYYY-MM-DD format for incremental monitoring.

## `alwaysReturnSummary` (type: `boolean`):

Save aggregate ratings even when no review passes the cutoff date.

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

Optional Apify Proxy fallback for rate-limited requests. Direct HTTP is used by default.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.hrs.com/en/hotel/391864"
    }
  ],
  "hotelIds": [],
  "maxReviewsPerHotel": 20,
  "alwaysReturnSummary": true
}
```

# Actor output Schema

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

Current public HRS guest review records with comments and rating categories.

## `summaries` (type: `string`):

Aggregate hotel scores, counts, recommendation ratios, and traveler segments.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.hrs.com/en/hotel/391864"
        }
    ],
    "maxReviewsPerHotel": 20,
    "alwaysReturnSummary": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/hrs-hotel-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 = {
    "startUrls": [{ "url": "https://www.hrs.com/en/hotel/391864" }],
    "maxReviewsPerHotel": 20,
    "alwaysReturnSummary": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/hrs-hotel-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 '{
  "startUrls": [
    {
      "url": "https://www.hrs.com/en/hotel/391864"
    }
  ],
  "maxReviewsPerHotel": 20,
  "alwaysReturnSummary": true
}' |
apify call automation-lab/hrs-hotel-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HRS Hotel Reviews Scraper",
        "description": "Extract public HRS guest reviews, comments, category ratings, traveler segments, and hotel summaries by hotel URL or ID. Fast HTTP output for reputation monitoring.",
        "version": "0.1",
        "x-build-id": "ZeChHhDfX2Cd9oF8d"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~hrs-hotel-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-hrs-hotel-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/automation-lab~hrs-hotel-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-hrs-hotel-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/automation-lab~hrs-hotel-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-hrs-hotel-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",
                "properties": {
                    "startUrls": {
                        "title": "🏨 HRS hotel URLs",
                        "type": "array",
                        "description": "Public HRS hotel detail URLs such as https://www.hrs.com/en/hotel/391864.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "hotelIds": {
                        "title": "HRS hotel IDs",
                        "type": "array",
                        "description": "Numeric HRS hotel IDs. You can combine these with hotel URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerHotel": {
                        "title": "Maximum reviews per hotel",
                        "minimum": 0,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum current public review records saved from each page. HRS may expose fewer records.",
                        "default": 20
                    },
                    "cutoffDate": {
                        "title": "Only reviews on or after",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive cutoff date in YYYY-MM-DD format for incremental monitoring."
                    },
                    "alwaysReturnSummary": {
                        "title": "Always return hotel summary",
                        "type": "boolean",
                        "description": "Save aggregate ratings even when no review passes the cutoff date.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy fallback for rate-limited requests. Direct HTTP is used by default."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```