# Booking Reviews Scraper (`reviewly/booking-reviews-scraper`) Actor

Scrapes reviews from Booking.com hotel pages

- **URL**: https://apify.com/reviewly/booking-reviews-scraper.md
- **Developed by:** [Reviewly](https://apify.com/reviewly) (community)
- **Categories:** Travel, Other, AI
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 record scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Booking.com Reviews Scraper — Extract Hotel Reviews at Scale

**Pull thousands of Booking.com guest reviews in minutes — with no API key, no manual work, and no blocks.**

Whether you manage a hotel's reputation, conduct hospitality research, or build a competitive intelligence tool, this actor gives you structured, fresh review data straight from Booking.com's live database.

- ✅ Scrapes **any Booking.com hotel page** — no account required
- ✅ Bypasses **WAF and bot protection** automatically
- ✅ Extracts reviews in **clean, structured JSON** ready for analysis
- ✅ Supports **bulk scraping** across multiple properties in one run
- ✅ Pay only for what you scrape — **$0.001 per review**

---

### 📌 What This Actor Does

This Apify Actor extracts guest reviews from Booking.com hotel pages — the same reviews guests see when they search for accommodation.

For each hotel URL you provide, the actor fetches:
- Full guest reviews (positive and negative comments, separated)
- Star ratings on a 1–5 scale
- Guest names, check-in dates, and room types
- Hotel management replies
- Hotel-level summary (overall score, rating distribution)

**Who is this for?**

- 🏨 **Hotel owners & managers** monitoring their reputation and benchmarking competitors
- 📊 **Market researchers & analysts** studying hospitality trends across regions
- 🏢 **OTAs & travel platforms** enriching their own databases with third-party social proof
- 🤖 **AI & NLP teams** building sentiment analysis models on real hospitality data
- 💼 **Reputation management agencies** tracking client portfolios at scale

---

### ✨ Key Features

- **Bulk scraping** — provide a list of hotel URLs and scrape them all in a single run
- **Pagination handled automatically** — fetches all review pages without any configuration
- **Date filtering** — set a stop date to only collect reviews newer than a given cutoff, great for weekly or monthly monitoring workflows
- **Review limit control** — cap the number of reviews per hotel to control cost and runtime
- **Separated positive/negative text** — Booking.com stores positive and negative comments as distinct fields; this actor preserves that structure so you don't have to parse it yourself
- **Hotel management replies** — captures the owner's response to each review, if present
- **Room-level data** — includes the room name and ID the guest stayed in
- **WAF challenge solver** — automatically handles AWS WAF JavaScript challenges that Booking.com deploys to block scrapers; no manual intervention required
- **Residential proxy support** — runs through Apify's residential proxy network for high success rates

---

### 🧠 Why This Actor Is Different

Most Booking.com scrapers parse the rendered HTML page — which breaks every time Booking.com updates its frontend layout. **This actor calls Booking.com's internal GraphQL API directly**, the same endpoint the browser itself uses. That means:

| | This Actor | Typical HTML Scrapers |
|---|---|---|
| Data freshness | Live from the API | Depends on page render |
| Resilience to layout changes | High — API contract is stable | Low — breaks on CSS/HTML changes |
| Positive/negative text separated | ✅ Yes | ❌ Usually merged |
| Room details included | ✅ Yes | ❌ Rarely |
| Management replies | ✅ Yes | ❌ Often missed |
| WAF bypass | ✅ Automatic | ❌ Often blocks |
| Pricing | $0.001 / review | Varies |

---

### ⚙️ Input Configuration

#### Input fields

| Field | Type | Required | Description |
|---|---|---|---|
| `startUrls` | Array of URLs | ✅ Yes | List of Booking.com hotel page URLs to scrape |
| `maxNumberOfReviews` | Integer | No | Maximum reviews to collect per hotel. Leave empty or set to `0` to collect all available reviews. Default: `100` |
| `targetDate` | Date (ISO) | No | Stop collecting reviews older than this date. Useful for incremental/scheduled scraping. Leave empty to disable. |
| `proxyConfiguration` | Object | No | Proxy settings. Defaults to Apify Residential Proxy (US). Change country if you need reviews in a specific language. |

#### Example input

```json
{
  "startUrls": [
    { "url": "https://www.booking.com/hotel/fr/edenarc.en-gb.html" },
    { "url": "https://www.booking.com/hotel/es/hotel-arts-barcelona.en-gb.html" }
  ],
  "maxNumberOfReviews": 500,
  "targetDate": "2024-01-01",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "FR"
  }
}
````

#### Tips for best results

> **Use the full hotel URL.** Booking.com short URLs (e.g., `booking.com/hotel/fr/name.html`) work, but URLs with query parameters (`dest_id`, `aid`, `label`) help the actor resolve the hotel faster and more reliably.

> **Set `apifyProxyCountry` to match the hotel's country.** Reviews on Booking.com are sometimes language-filtered by region. Using a French proxy for French hotels gives you the most complete review set.

> **Use `targetDate` for scheduled monitoring.** If you run this actor weekly, set `targetDate` to 7 days ago to only fetch new reviews since your last run — saves cost and time.

> **Leave `maxNumberOfReviews` empty for complete datasets.** Setting it to `0` or leaving it blank collects every available review for the property.

***

### 📤 Output Format

Each record in the dataset represents **one hotel**, containing:

- An `entity` object with hotel-level metadata
- A `reviews` array with all scraped reviews for that hotel

#### Sample output

```json
{
  "entity": {
    "businessName": "Hôtel Eden Arc",
    "businessUrl": "https://www.booking.com/hotel/fr/edenarc.en-gb.html",
    "score": 8.6,
    "totalNumberOfReviews": 1243,
    "ratings": {
      "one": 12,
      "two": 28,
      "three": 95,
      "four": 310,
      "five": 798
    }
  },
  "reviews": [
    {
      "reviewId": "/reviews/fr/hotel/edenarc-fr.en-gb.html?...",
      "title": "Perfect mountain escape",
      "room_name": "Superior Double Room with Mountain View",
      "room_id": "12345678",
      "text": {
        "positive": "The view from our room was breathtaking. Staff were incredibly welcoming and helpful throughout our stay.",
        "negative": "The spa was closed for renovation during our visit, which was a bit disappointing."
      },
      "rating": 5,
      "datetime": "2025-03-14T00:00:00.000Z",
      "consumerName": "Marie G.",
      "dateOfExperience": "2025-03-10T00:00:00.000Z",
      "reviewUrl": "/reviews/fr/hotel/edenarc-fr.en-gb.html?...",
      "reply": "Thank you so much for your kind words, Marie! We hope to welcome you back once the spa renovation is complete."
    }
  ]
}
```

#### Output field reference

**`entity` object**

| Field | Description |
|---|---|
| `businessName` | Hotel name as shown on Booking.com |
| `businessUrl` | Clean hotel page URL (no tracking params) |
| `score` | Overall Booking.com score (out of 10) |
| `totalNumberOfReviews` | Total review count on Booking.com |
| `ratings.one` – `ratings.five` | Count of reviews per star band (1–5 stars) |

**Each review in `reviews`**

| Field | Description |
|---|---|
| `reviewId` | Unique review identifier (relative URL path) |
| `title` | Review headline written by the guest |
| `room_name` | Name of the room type booked |
| `room_id` | Internal Booking.com room type ID |
| `text.positive` | Positive comments from the guest |
| `text.negative` | Negative comments from the guest |
| `rating` | Guest rating, converted to 1–5 scale |
| `datetime` | Date the review was submitted (ISO 8601) |
| `consumerName` | Guest display name |
| `dateOfExperience` | Guest check-in date (ISO 8601) |
| `reviewUrl` | Direct link to the review on Booking.com |
| `reply` | Hotel management's reply, or `null` if none |

***

### ▶️ How to Use

#### Option 1 — Apify Console (No Code)

1. Open the actor page on [Apify Store](https://apify.com/store)
2. Click **Try for free**
3. Paste your Booking.com hotel URL(s) in the **Start URLs** field
4. Set your desired review limit and optional stop date
5. Click **Start** and wait for the run to finish
6. Download your results as **JSON, CSV, or Excel**

#### Option 2 — Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{ "url": "https://www.booking.com/hotel/fr/edenarc.en-gb.html" }],
    "maxNumberOfReviews": 200
  }'
```

#### Option 3 — Schedule it (Automated Monitoring)

1. Go to **Schedules** in your Apify account
2. Create a new schedule (e.g., every Monday at 9am)
3. Attach this actor with your hotel URLs and a rolling `targetDate` set to 7 days ago
4. Connect to a webhook or Google Sheets integration for automatic delivery

***

### 📈 Use Cases

#### 1. Hotel Reputation Monitoring

Track what guests are saying about your property in real time. Run the actor weekly, filter for new reviews since your last run using `targetDate`, and pipe results into your CRM or Slack for instant alerts on negative feedback.

#### 2. Competitive Intelligence

Scrape the top 20 hotels in your destination city. Compare average ratings, score distributions, and recurring complaints in positive/negative text fields to identify gaps your property can exploit.

#### 3. Hospitality Market Research

Build a dataset of thousands of hotels across Europe and analyse review trends by region, price tier, or property type. The structured positive/negative split makes sentiment analysis straightforward.

#### 4. AI Training Data

Generate large, labelled datasets of real guest reviews for training sentiment classifiers, summarisation models, or hospitality-specific NLP tools. The `text.positive`/`text.negative` separation gives you pre-labelled training examples.

#### 5. OTA & Aggregator Enrichment

If you run a travel comparison platform, enrich your hotel listings with live Booking.com review summaries, scores, and rating distributions to improve trust signals for your users.

***

### 🛠️ Advanced Tips

#### Scraping a large hotel with 5,000+ reviews

Set `maxNumberOfReviews` to `0` (no limit) and increase the actor memory in the **Advanced options** if the run times out. The actor paginates automatically — no extra configuration needed.

#### Getting reviews in a specific language

Booking.com serves reviews based on the proxy location. To get French-language reviews, set:

```json
"proxyConfiguration": {
  "useApifyProxy": true,
  "apifyProxyGroups": ["RESIDENTIAL"],
  "apifyProxyCountry": "FR"
}
```

#### Running for hundreds of hotels

Provide all URLs in the `startUrls` array. The actor processes them sequentially in a single run. For very large batches (100+ hotels), consider splitting them across multiple scheduled runs to avoid memory pressure.

#### Saving cost on repeat runs

Use `targetDate` set to your last run date. The actor stops pagination as soon as it encounters reviews older than the cutoff — you only pay for new reviews, not the entire history.

#### Integrating with Google Sheets

Use Apify's native [Google Sheets integration](https://apify.com/apify/google-sheets-import-export) to push results directly to a spreadsheet after each run — no coding required.

***

### ❓ FAQ & Troubleshooting

**Q: Do I need a Booking.com account?**
No. The actor scrapes public review pages. No login is required.

**Q: Is it legal to scrape Booking.com?**
Scraping publicly available data for research, analysis, and personal use is generally permitted in many jurisdictions. Always review Booking.com's Terms of Service and consult legal counsel for commercial applications. This actor only accesses data that any visitor can see without logging in.

**Q: Why did my run return fewer reviews than the hotel shows?**
Booking.com occasionally limits the total number of reviews accessible through their API (typically capping at ~10,000 most recent reviews for very popular properties). This is a platform-level restriction, not an actor bug.

**Q: The actor failed — what do I do?**
Check the **Log** tab in your run. Common causes:

- The hotel URL is invalid or the page no longer exists — verify the URL in a browser
- The run was blocked by WAF — try again; the actor automatically retries, but persistent blocks may require switching proxy country
- The hotel page structure changed — contact support

**Q: The `rating` field shows values 1–5, but Booking.com uses 1–10. Why?**
The actor normalises ratings to a 1–5 scale (divides by 2 and rounds) for consistency with other review platforms. The raw score is not preserved in the current output.

**Q: Can I scrape reviews in multiple languages?**
Booking.com serves reviews in the guest's original language. The actor does not filter by language — all reviews are included regardless of the language they were written in.

**Q: How fresh is the data?**
Every run fetches live data directly from Booking.com. There is no cache. Reviews published minutes ago will appear in your results.

**Q: How much does it cost?**
The actor charges **$0.001 per review scraped** (Pay-Per-Event billing). Scraping 1,000 reviews costs $1. There is no base run fee — you only pay for what you actually collect.

***

### 📞 Support

Have a question, found a bug, or need a custom feature?

- 📧 **Email:** <me@ahmedhrid.com>
- 🐛 **Report issues:** Use the **Issues** tab on the actor page
- 💬 **General questions:** Use the **Discussions** section on the Apify platform

Response time is typically within 24 hours on business days.

***

*Built with ❤️ using [Apify](https://apify.com). Not affiliated with Booking.com.*

# Actor input Schema

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

List of Booking.com hotel page URLs to scrape.

## `maxNumberOfReviews` (type: `integer`):

Maximum number of reviews to collect per hotel. Leave empty to collect all.

## `targetDate` (type: `string`):

Stop collecting reviews older than this date (ISO format, e.g. 2026-01-01). Leave empty to disable.

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

Proxy servers used by the scraper to hide its origin. <strong>Recommended for reliable scraping</strong> to avoid rate limiting and blocking.<br><br>Select 'Apify Proxy (automatic)' for best results.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.booking.com/hotel/fr/edenarc.en-gb.html?aid=311984&label=skissim-classic-residence-les-lauzieres-lpXintRaKPcYTlSFJC%2AtOwS626140877747%3Apl%3Ata%3Ap1%3Ap2%3Aac%3Aap%3Aneg%3Afi%3Atikwd-351628969834%3Alp9073697%3Ali%3Adec%3Adm%3Appccp%3DUmFuZG9tSVYkc2RlIyh9YTQUGSsRwx9_3qo3uPTHyoo&sid=2bae9fa71f2b108f274cfc89f0db65e3&dest_id=900039801&dest_type=city&dist=0&group_adults=2&group_children=0&hapos=4&hpos=4&no_rooms=1&req_adults=2&req_children=0&room1=A%2CA&sb_price_type=total&sr_order=popularity&srepoch=1772548274&srpvid=27c0661576e009e4&type=total&ucfs=1&"
    }
  ],
  "maxNumberOfReviews": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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.booking.com/hotel/fr/edenarc.en-gb.html?aid=311984&label=skissim-classic-residence-les-lauzieres-lpXintRaKPcYTlSFJC%2AtOwS626140877747%3Apl%3Ata%3Ap1%3Ap2%3Aac%3Aap%3Aneg%3Afi%3Atikwd-351628969834%3Alp9073697%3Ali%3Adec%3Adm%3Appccp%3DUmFuZG9tSVYkc2RlIyh9YTQUGSsRwx9_3qo3uPTHyoo&sid=2bae9fa71f2b108f274cfc89f0db65e3&dest_id=900039801&dest_type=city&dist=0&group_adults=2&group_children=0&hapos=4&hpos=4&no_rooms=1&req_adults=2&req_children=0&room1=A%2CA&sb_price_type=total&sr_order=popularity&srepoch=1772548274&srpvid=27c0661576e009e4&type=total&ucfs=1&"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("reviewly/booking-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.booking.com/hotel/fr/edenarc.en-gb.html?aid=311984&label=skissim-classic-residence-les-lauzieres-lpXintRaKPcYTlSFJC%2AtOwS626140877747%3Apl%3Ata%3Ap1%3Ap2%3Aac%3Aap%3Aneg%3Afi%3Atikwd-351628969834%3Alp9073697%3Ali%3Adec%3Adm%3Appccp%3DUmFuZG9tSVYkc2RlIyh9YTQUGSsRwx9_3qo3uPTHyoo&sid=2bae9fa71f2b108f274cfc89f0db65e3&dest_id=900039801&dest_type=city&dist=0&group_adults=2&group_children=0&hapos=4&hpos=4&no_rooms=1&req_adults=2&req_children=0&room1=A%2CA&sb_price_type=total&sr_order=popularity&srepoch=1772548274&srpvid=27c0661576e009e4&type=total&ucfs=1&" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("reviewly/booking-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.booking.com/hotel/fr/edenarc.en-gb.html?aid=311984&label=skissim-classic-residence-les-lauzieres-lpXintRaKPcYTlSFJC%2AtOwS626140877747%3Apl%3Ata%3Ap1%3Ap2%3Aac%3Aap%3Aneg%3Afi%3Atikwd-351628969834%3Alp9073697%3Ali%3Adec%3Adm%3Appccp%3DUmFuZG9tSVYkc2RlIyh9YTQUGSsRwx9_3qo3uPTHyoo&sid=2bae9fa71f2b108f274cfc89f0db65e3&dest_id=900039801&dest_type=city&dist=0&group_adults=2&group_children=0&hapos=4&hpos=4&no_rooms=1&req_adults=2&req_children=0&room1=A%2CA&sb_price_type=total&sr_order=popularity&srepoch=1772548274&srpvid=27c0661576e009e4&type=total&ucfs=1&"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call reviewly/booking-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Booking Reviews Scraper",
        "description": "Scrapes reviews from Booking.com hotel pages",
        "version": "0.0",
        "x-build-id": "4sglkV3HqXbADcaHS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/reviewly~booking-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-reviewly-booking-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/reviewly~booking-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-reviewly-booking-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/reviewly~booking-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-reviewly-booking-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": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of Booking.com hotel page URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxNumberOfReviews": {
                        "title": "Max number of reviews",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per hotel. Leave empty to collect all.",
                        "default": 100
                    },
                    "targetDate": {
                        "title": "Stop date",
                        "type": "string",
                        "description": "Stop collecting reviews older than this date (ISO format, e.g. 2026-01-01). Leave empty to disable."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy servers used by the scraper to hide its origin. <strong>Recommended for reliable scraping</strong> to avoid rate limiting and blocking.<br><br>Select 'Apify Proxy (automatic)' for best results.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
