# Klook MCP Server (`axlymxp/klook-mcp-server`) Actor

MCP server + scraper for Klook. Search activities, browse cities, resolve destinations and pull categories live from Claude, ChatGPT, Cursor and other AI agents — or run it as a classic Klook scraper. Prices, ratings, reviews, bookings and images as structured data.

- **URL**: https://apify.com/axlymxp/klook-mcp-server.md
- **Developed by:** [axly](https://apify.com/axlymxp) (community)
- **Categories:** Travel, AI, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 MCP Server

Give your AI assistant **live access to Klook** — the travel-experiences
marketplace. This Actor runs as a **Model Context Protocol (MCP) server** so
Claude, ChatGPT, Cursor, n8n and custom agents can search activities, browse
cities, resolve destinations and pull categories on demand. It also works as a
**classic one-shot scraper** if you just want a dataset.

Backed by Klook's **mobile API** (with in-Python request signing and DataDome
handling) for reliable, structured results.

### Who it's for

- **AI-agent & app builders** — add real Klook activity search to an assistant or
  a RAG/travel-planning workflow without touching anti-bot or auth.
- **Travel-tech developers** — a hosted MCP endpoint for activity data; no scraping
  code to maintain.
- **Analysts & researchers** — interactively explore activities, prices and demand
  by city from a chat interface.

### MCP tools

| Tool                        | What it does                                                                          |
| --------------------------- | ------------------------------------------------------------------------------------- |
| `search_klook_activities`   | Keyword search → activities with price, rating, reviews, bookings, city, GPS, image.  |
| `get_klook_city_activities` | Browse a city's full activity catalog by numeric city ID.                             |
| `search_klook_suggestions`  | Autocomplete cities (with IDs) and activities for a term — resolve destination names. |
| `get_klook_city_info`       | City overview: travel tips, weather, hot activities, nearby cities.                   |
| `get_klook_activity_images` | Image gallery for a specific activity.                                                |
| `get_klook_categories`      | Klook's top-level activity category / vertical tree.                                  |

### Connect it to an AI assistant

1. Start this Actor in **Standby mode** (it launches an MCP server).
2. Point your MCP client at the server URL + `/mcp` (Streamable HTTP transport).

Example MCP client config:

```json
{
    "mcpServers": {
        "klook": {
            "url": "https://<your-actor-standby-url>/mcp"
        }
    }
}
```

Then ask your assistant things like *"Find the top-rated Universal Studios Japan
tickets on Klook"* or *"What are the most-booked activities in Tokyo?"*.

### Classic scraper mode

Prefer a dataset? Run it normally with input:

```json
{
    "searchQueries": ["universal studios japan"],
    "cityIds": ["28"],
    "sortBy": "most_reviewed",
    "maxItems": 50
}
```

Each activity is pushed as a structured row (same fields as the tool output):
`activity_id`, `title`, `activity_url`, `rating`, `review_count`, `booked_count`,
`sell_price`, `price_from`/`price_to`, `city_name`, `country_name`, `latitude`,
`longitude`, `image_url`, `scraped_at`, and more.

### Scheduling & integrations

Schedule classic-mode runs and pipe results to Google Sheets, Make, Zapier, S3 or
your API via Apify webhooks and the dataset API (JSON, CSV, Excel).

### FAQ

**What is MCP?** The Model Context Protocol — an open standard that lets AI
assistants call external tools. This Actor is a hosted MCP server for Klook.

**Where does the data come from?** Klook's official mobile backend API — the same
source the Klook app uses.

**How fresh is it?** Live at call time.

**Do I need the sibling scraper?** No — this Actor also scrapes to a dataset. Use
the **Klook Activities & Experiences Scraper** if you only want bulk dataset runs
without MCP.

**Is it legal?** You are responsible for your use of the data; it collects publicly
available catalog information. Respect Klook's terms and applicable laws.

# Actor input Schema

## `searchQueries` (type: `array`):

Optional (classic-scrape mode). Keywords to search Klook activities for.

## `cityIds` (type: `array`):

Optional (classic-scrape mode). Klook numeric city IDs to browse (e.g. 28 = Tokyo).

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

Ordering of returned activities in classic-scrape mode.

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

Classic-scrape mode: max activities per query/city.

## Actor input object example

```json
{
  "searchQueries": [
    "universal studios japan"
  ],
  "cityIds": [
    "28"
  ],
  "sortBy": "default",
  "maxItems": 50
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("axlymxp/klook-mcp-server").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("axlymxp/klook-mcp-server").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 '{}' |
apify call axlymxp/klook-mcp-server --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/QARcV2JKA8O0rElk6/builds/1qv8CORlNx2slt55r/openapi.json