# Klook Reviews Scraper (`automation-lab/klook-reviews-scraper`) Actor

Extract public traveler reviews from Klook activities and hotels with ratings, translations, images, reviewer details, likes, and booking context.

- **URL**: https://apify.com/automation-lab/klook-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

Pay per event

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

## Klook Reviews Scraper

Collect public traveler feedback from Klook activity and hotel pages with the **Klook Reviews Scraper**.

Turn review pages into structured records containing review text, translations, ratings, images, reviewer details, likes, package names, room context, and timestamps. Use the output in reputation dashboards, guest-experience reports, competitive research, sentiment analysis, or AI workflows.

The Actor accepts normal Klook URLs. You do not need to find an API endpoint, provide a Klook account, or manually copy page IDs.

### What does Klook Reviews Scraper do?

Klook Reviews Scraper extracts one dataset row per public review from:

- 🎟️ Klook activities, tours, attractions, experiences, and tickets
- 🏨 Klook hotel detail pages
- 🌍 Locale-specific URLs such as `en-US`, `ko`, `ja`, and `zh-TW`

It supports newest, relevant, high-rating, and low-rating ordering for activities. A date cutoff helps scheduled runs focus on recent feedback.

### Why use this Klook review extractor?

Manual review collection is slow and difficult to repeat. This Actor provides:

- ✅ Structured JSON, CSV, Excel, XML, and RSS exports
- ✅ Original and Klook-translated review text
- ✅ Ratings, labels, dates, reviewer names, and avatars
- ✅ Activity package names, review likes, and images
- ✅ Hotel room, guest, stay-length, and language context
- ✅ Pagination, deduplication, retry handling, and output limits
- ✅ Direct integration with Apify schedules, webhooks, API, and MCP

### Who is it for?

**Tour and activity operators** can monitor feedback on their products and competing attractions.

**Hotel reputation teams** can aggregate guest comments, scores, room context, and recurring service themes.

**Destination marketers** can compare visitor sentiment across attractions and accommodation partners.

**Travel agencies and OTAs** can build internal quality dashboards and supplier reports.

**Researchers and data teams** can create clean multilingual review datasets for analysis.

### Supported Klook pages

Use full public URLs in either of these forms:

```text
https://www.klook.com/en-US/activity/3303-eiffel-tower-skip-the-line-entry-paris/
https://www.klook.com/en-US/hotels/detail/285841-hotel-gracery-shinjuku/
````

The Actor reads the numeric page ID and source type from the URL. Search result pages, destination pages, account pages, and booking pages are not supported.

### What Klook review data can I extract?

| Field | Description |
|---|---|
| `sourceType` | `activity` or `hotel` |
| `pageId` | Klook activity or hotel ID |
| `pageUrl` | Normalized source URL |
| `reviewId` | Klook review ID or deterministic hotel-review fingerprint |
| `reviewTime` | Review date or timestamp |
| `contentOriginal` | Original traveler review |
| `contentTranslated` | Klook-provided translation, when available |
| `score` | Numeric review score |
| `scoreLabel` | Human-readable rating label |
| `reviewerName` | Public masked display name |
| `reviewerAvatarUrl` | Public avatar image URL |
| `images` | Traveler-uploaded image URLs |
| `likeCount` | Activity review likes |
| `packageId` / `packageName` | Activity package context |
| `checkInInfo` | Hotel room, guests, and stay context |
| `originalLanguage` | Hotel review source language |
| `translatedLanguage` | Hotel translation language |
| `hasReply` | Whether an activity review has a reply |
| `scrapedAt` | UTC extraction timestamp |

### Input options

| Input | Type | Default | Purpose |
|---|---|---:|---|
| `startUrls` | array | required | Activity and hotel detail URLs |
| `maxReviewsPerUrl` | integer | 20 | Per-page review cap |
| `maxItems` | integer | 50 | Overall dataset cap |
| `sortBy` | string | newest | Activity review order |
| `language` | string | `en-US` | Locale for translated content |
| `cutoffDate` | date | empty | Exclude older reviews |
| `proxyConfiguration` | object | empty | Optional Apify Proxy fallback |

Keep the first run small. Increase limits after confirming that the selected Klook pages contain the review volume you expect.

### Example: scrape newest activity reviews

```json
{
  "startUrls": [
    {
      "url": "https://www.klook.com/en-US/activity/3303-eiffel-tower-skip-the-line-entry-paris/"
    }
  ],
  "maxReviewsPerUrl": 10,
  "maxItems": 10,
  "sortBy": "sort_review_time_desc",
  "language": "en-US"
}
```

This workflow is useful for tracking recently published attraction feedback.

### Example: extract hotel guest feedback

```json
{
  "startUrls": [
    {
      "url": "https://www.klook.com/en-US/hotels/detail/285841-hotel-gracery-shinjuku/"
    }
  ],
  "maxReviewsPerUrl": 25,
  "maxItems": 25,
  "language": "en-US"
}
```

Hotel output includes room and stay context when Klook exposes it.

### Example: monitor reviews after a date

```json
{
  "startUrls": [
    { "url": "https://www.klook.com/en-US/activity/3303-eiffel-tower-skip-the-line-entry-paris/" },
    { "url": "https://www.klook.com/en-US/hotels/detail/285841-hotel-gracery-shinjuku/" }
  ],
  "maxReviewsPerUrl": 100,
  "maxItems": 200,
  "sortBy": "sort_review_time_desc",
  "language": "en-US",
  "cutoffDate": "2026-01-01"
}
```

Run this input on an Apify schedule and send the dataset to a webhook or data warehouse.

### Example output

```json
{
  "sourceType": "activity",
  "pageId": "3303",
  "pageUrl": "https://www.klook.com/en-US/activity/3303-eiffel-tower-skip-the-line-entry-paris/",
  "reviewId": "18903604",
  "reviewTime": "2026-07-14T06:06:06.000Z",
  "contentOriginal": "Unfortunately our tour was canceled...",
  "contentTranslated": "Unfortunately our tour was canceled...",
  "score": 4,
  "scoreLabel": "Great",
  "images": [],
  "likeCount": 0,
  "reviewerName": "Metua *************",
  "packageId": "323076",
  "packageName": "Eiffel Tower: 2nd floor + Seine River cruise",
  "hasReply": false,
  "scrapedAt": "2026-07-15T03:15:00.000Z"
}
```

Optional fields are omitted when Klook does not expose them.

### How to run the scraper

1. Open **Klook Reviews Scraper** on Apify.
2. Add one or more activity or hotel detail URLs.
3. Choose small per-URL and overall review limits.
4. Select an activity sort order and Klook language.
5. Optionally add a date cutoff or proxy configuration.
6. Click **Start**.
7. Preview or export the default dataset.

### Sorting and date cutoffs

Activity pages support:

- `sort_most_relevant`
- `sort_review_time_desc`
- `sort_score_high_to_low`
- `sort_score_low_to_high`

Klook returns hotel reviews newest first. For efficient recurring monitoring, combine `sort_review_time_desc` with `cutoffDate`.

A cutoff filters output. If newest ordering is active, the Actor can also stop pagination after reaching older records.

### How much does it cost to scrape Klook reviews?

The Actor uses pay-per-event pricing:

- **Actor start:** $0.005 per run
- **Klook review:** tiered by Apify plan; current BRONZE price is $0.00037345 per saved review

You pay for successfully saved review records, not requested empty pages. Apify plan discounts reduce the per-review price on higher tiers. Check the Pricing tab for the live amount before a large run.

A ten-review smoke test is approximately the start fee plus ten review events.

### Export and integrations

Use Apify's dataset export to download:

- JSON for applications and pipelines
- CSV or Excel for analysts
- XML or RSS for compatible tools
- HTML table previews for quick review

Useful automation patterns include:

- 🔔 Webhook new reviews into Slack or Microsoft Teams
- 📊 Load scheduled datasets into BigQuery or Snowflake
- 🧾 Send hotel review summaries to Airtable or Google Sheets
- 🧠 Feed multilingual text into sentiment or topic models
- 🔄 Compare review IDs against the previous scheduled run

### 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/klook-reviews-scraper').call({
  startUrls: [{
    url: 'https://www.klook.com/en-US/activity/3303-eiffel-tower-skip-the-line-entry-paris/'
  }],
  maxReviewsPerUrl: 10,
  maxItems: 10,
  sortBy: 'sort_review_time_desc',
  language: 'en-US'
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/klook-reviews-scraper').call(run_input={
    'startUrls': [{
        'url': 'https://www.klook.com/en-US/hotels/detail/285841-hotel-gracery-shinjuku/'
    }],
    'maxReviewsPerUrl': 20,
    'maxItems': 20,
    'language': 'en-US',
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~klook-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url": "https://www.klook.com/en-US/activity/3303-eiffel-tower-skip-the-line-entry-paris/"}],
    "maxReviewsPerUrl": 10,
    "maxItems": 10,
    "sortBy": "sort_review_time_desc",
    "language": "en-US"
  }'
```

Poll the returned run ID or use `run-sync-get-dataset-items` for small synchronous jobs.

### Use with Apify MCP

Connect Claude or another MCP client to Apify at:

```text
https://mcp.apify.com/?tools=automation-lab/klook-reviews-scraper
```

**Claude Code setup**

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

**Claude Desktop setup**

Add this to the Claude Desktop MCP configuration:

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

**Cursor setup**

Add the same `mcpServers` JSON to Cursor's MCP settings and authorize your Apify account when prompted.

**VS Code setup**

Open the MCP server configuration in VS Code, add the HTTP URL above, and complete Apify authentication.

Example prompts:

- “Extract the newest 20 reviews from this Klook attraction.”
- “Collect hotel guest comments since January and summarize cleanliness concerns.”
- “Compare ratings and common themes across these Klook activity URLs.”

### Scheduling a Klook review monitor

Create an Apify schedule with newest sorting and a recent cutoff date. A practical workflow is:

1. Run daily or weekly.
2. Store the latest review IDs in your destination system.
3. Ignore IDs already processed.
4. Alert only on new low-score reviews.
5. Update the cutoff periodically to limit unnecessary pagination.

The Actor itself deduplicates records within each run.

### Reliability and proxy behavior

The Actor uses Klook's anonymous structured review interfaces rather than rendering the protected website. This keeps runs fast and memory-efficient.

Direct requests are attempted by default. If your account or geography receives transient blocks, configure Apify Proxy in the input. Requests use bounded retries and do not loop indefinitely.

Klook can change its public interfaces. Check run logs if a previously valid URL begins returning no data.

### Limitations

- Only public activity and hotel detail URLs are supported.
- Activity sorting does not apply to hotels.
- Klook may omit review IDs for hotel records; the Actor creates deterministic fallback IDs.
- Some reviews have no translation, images, likes, avatar, or package context.
- Review counts can change while pagination is running.
- Deleted, moderated, private, or region-restricted content cannot be returned.
- The Actor does not scrape private bookings or account data.

### Is it legal to scrape Klook reviews?

This Actor extracts publicly visible review data. Whether a specific use is lawful depends on your jurisdiction, purpose, volume, retention, and contractual obligations.

Do not use review data to harass, identify, or profile travelers. Avoid republishing personal details unnecessarily. Follow applicable privacy, database, copyright, and consumer-protection rules, as well as Klook's terms.

You are responsible for your input and use of the output.

### Troubleshooting

**The Actor says the URL is unsupported.**

Use a Klook URL containing `/activity/{numeric-id}` or `/hotels/detail/{numeric-id}`. Do not use a search, destination, or checkout URL.

**The dataset is empty.**

Confirm that the page currently has public reviews, remove an overly recent `cutoffDate`, and inspect logs. Try a small run with optional Apify Proxy settings if Klook blocked the endpoint.

**Fewer reviews were returned than requested.**

The page may contain fewer public records, the date cutoff may remove older reviews, or the global `maxItems` limit may have been reached first.

### FAQ

**Does it require a Klook login?**

No. It extracts anonymous public review data.

**Can it scrape both activities and hotels in one run?**

Yes. Add both URL types to `startUrls`; output uses one normalized review schema.

**Can I get translated review text?**

Yes, when Klook provides a translation for the requested locale.

**Can I sort hotel reviews by rating?**

No. Klook's hotel review interface supplies newest-first records. Activity pages support all four sort modes.

**How do I collect only new reviews?**

Use newest sorting and `cutoffDate`, then schedule the Actor.

**Are duplicate reviews removed?**

Yes, duplicate source/page/review identifiers are suppressed within a run.

### Related travel scrapers

Explore other Automation Lab actors for adjacent travel research:

- [Booking Scraper](https://apify.com/automation-lab/booking-scraper)
- [Tripadvisor Scraper](https://apify.com/automation-lab/tripadvisor-scraper)
- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder)

Use Klook Reviews Scraper when your source pages are specifically Klook activities or hotels and you need one row per traveler review.

### Support

If a valid public Klook activity or hotel URL fails, open an Actor issue with:

- the URL type (activity or hotel),
- a redacted example URL if possible,
- the run ID,
- the expected and actual record counts,
- and the relevant log message.

Do not include private booking details, account credentials, or personal travel documents.

# Actor input Schema

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

Public Klook activity and hotel detail pages. Add one or many URLs.

## `maxReviewsPerUrl` (type: `integer`):

Maximum reviews collected from each Klook page.

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

Maximum reviews saved across all input URLs.

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

Sort order for activity reviews. Hotel reviews are provided newest first by Klook.

## `language` (type: `string`):

Locale used for Klook's translated review text, such as en-US, ko, ja, or zh-TW.

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

Optional ISO date. Reviews older than this date are excluded.

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

Optional Apify Proxy settings used for retrying blocked Klook API requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.klook.com/en-US/activity/3303-eiffel-tower-skip-the-line-entry-paris/"
    }
  ],
  "maxReviewsPerUrl": 10,
  "maxItems": 10,
  "sortBy": "sort_review_time_desc",
  "language": "en-US"
}
```

# Actor output Schema

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

No description

# 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.klook.com/en-US/activity/3303-eiffel-tower-skip-the-line-entry-paris/"
        }
    ],
    "maxReviewsPerUrl": 10,
    "maxItems": 10,
    "sortBy": "sort_review_time_desc",
    "language": "en-US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/klook-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.klook.com/en-US/activity/3303-eiffel-tower-skip-the-line-entry-paris/" }],
    "maxReviewsPerUrl": 10,
    "maxItems": 10,
    "sortBy": "sort_review_time_desc",
    "language": "en-US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/klook-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.klook.com/en-US/activity/3303-eiffel-tower-skip-the-line-entry-paris/"
    }
  ],
  "maxReviewsPerUrl": 10,
  "maxItems": 10,
  "sortBy": "sort_review_time_desc",
  "language": "en-US"
}' |
apify call automation-lab/klook-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Klook Reviews Scraper",
        "description": "Extract public traveler reviews from Klook activities and hotels with ratings, translations, images, reviewer details, likes, and booking context.",
        "version": "0.1",
        "x-build-id": "HYffFi5X0PfQcnBLP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~klook-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-klook-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~klook-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-klook-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~klook-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-klook-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": "🎟️ Klook activity or hotel URLs",
                        "type": "array",
                        "description": "Public Klook activity and hotel detail pages. Add one or many URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviewsPerUrl": {
                        "title": "Reviews per URL",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum reviews collected from each Klook page.",
                        "default": 20
                    },
                    "maxItems": {
                        "title": "Total review limit",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum reviews saved across all input URLs.",
                        "default": 50
                    },
                    "sortBy": {
                        "title": "Activity review order",
                        "enum": [
                            "sort_most_relevant",
                            "sort_review_time_desc",
                            "sort_score_high_to_low",
                            "sort_score_low_to_high"
                        ],
                        "type": "string",
                        "description": "Sort order for activity reviews. Hotel reviews are provided newest first by Klook.",
                        "default": "sort_review_time_desc"
                    },
                    "language": {
                        "title": "Klook language",
                        "type": "string",
                        "description": "Locale used for Klook's translated review text, such as en-US, ko, ja, or zh-TW.",
                        "default": "en-US"
                    },
                    "cutoffDate": {
                        "title": "Reviews on or after",
                        "type": "string",
                        "description": "Optional ISO date. Reviews older than this date are excluded."
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy fallback",
                        "type": "object",
                        "description": "Optional Apify Proxy settings used for retrying blocked Klook API requests."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
