# Travel Tools MCP (`romy/travel-tools-mcp`) Actor

MCP server exposing live Klook, Booking.com, TripAdvisor, and GetYourGuide search/booking data as 12 callable tools for AI agents like Claude Desktop and Cursor.

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

## Pricing

from $0.01 / 1,000 results

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/actors/running/actors-in-store.md#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

### What does Travel Tools MCP do?

**Travel Tools MCP** is a [Model Context Protocol](https://modelcontextprotocol.io) server that exposes this account's four travel Actors — [Klook All-in-One API](https://apify.com/romy/klook-all-in-one-api), [Booking.com All-in-One API](https://apify.com/romy/booking-all-in-one-api), [TripAdvisor All-in-One API](https://apify.com/romy/tripadvisor-all-in-one-api), and [GetYourGuide All-in-One API](https://apify.com/romy/getyourguide-all-in-one-api) — as 12 callable tools for AI agents (Claude Desktop, Cursor, or any MCP client). One connection gives an agent hotel search, flight search, car rentals, tours & activities, and restaurant/attraction data across all four platforms.

It's a thin router, not a new data source: every tool call forwards to the matching Actor's own Standby REST API and returns its response, with a couple of tools also cleaning up an otherwise deeply nested raw payload into something a model can use directly (see Data notes).

### Why use Travel Tools MCP?

- **One MCP connection, four platforms** — no existing Apify Store MCP server combines Klook, Booking.com, TripAdvisor, and GetYourGuide into a single toolset
- **Always-on** — Standby mode means no cold start, tool calls respond in milliseconds
- **One flat, tiered fee per tool call, no separate per-Actor billing to track** — this server calls the four wrapped Actors internally and absorbs their own compute/proxy cost; you're charged one `tool-call`/`tool-call-proxy` event per call (see Pricing)
- **Real destination-id resolution, not raw IDs to guess** — `booking_search_destinations` extracts clean `{destId, name, subtitle}` results from Booking.com's deeply nested raw response, so an agent doesn't need to parse UI-component trees to find a bookable `dest_id`
- **Use cases:** travel-planning agents, itinerary builders, price-comparison bots, any AI assistant that needs live multi-platform travel data as a tool

### Tools

| Tool | Platform | Description |
| ---- | -------- | ------------ |
| `klook_search` | Klook | Search tours, activities, tickets, transport, and more |
| `klook_activity_detail` | Klook | Full detail for one activity by id |
| `booking_search_destinations` | Booking.com | Resolve a free-text place name to a `dest_id` |
| `booking_search_hotels` | Booking.com | Search hotels for a destination and date range |
| `booking_hotel_detail` | Booking.com | Full detail for one hotel by id |
| `booking_search_flights` | Booking.com | Search round-trip or one-way flights |
| `booking_search_car_rentals` | Booking.com | Search car rentals for a place name and date range |
| `tripadvisor_search` | TripAdvisor | Resolve a free-text place name to a `geo_id` |
| `tripadvisor_search_restaurants` | TripAdvisor | Search restaurants for a destination |
| `tripadvisor_search_attractions` | TripAdvisor | Search things-to-do/attractions for a destination |
| `getyourguide_search` | GetYourGuide | Search bookable tours and activities |
| `getyourguide_check_availability` | GetYourGuide | Real bookable time slots + live pricing for one date |

### How to use Travel Tools MCP

1. Get your [Apify API token](https://console.apify.com/account/integrations) — needed only to authenticate to this Actor's Standby endpoint and attribute your PPE charges, same as any other Apify Standby Actor.
2. Add this server to your MCP client (e.g. Claude Desktop, Cursor) at:
   ```
   https://romy--travel-tools-mcp.apify.actor/mcp
   ```
   with your token passed as a Bearer header:
   ```
   Authorization: Bearer <YOUR_APIFY_API_TOKEN>
   ```
3. Ask the agent something that needs travel data — it picks the right tool(s) itself, e.g. "Find me a 3-star hotel in Bangkok for Sept 24-26 and a rafting activity in Bali for two adults on Sept 15."

You can also call it directly as a raw JSON-RPC request, for testing:

```bash
curl -N https://romy--travel-tools-mcp.apify.actor/mcp \
  -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" \
  -H "Authorization: Bearer <YOUR_APIFY_API_TOKEN>" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"getyourguide_search","arguments":{"query":"Bali"}}}'
```

### Parameters

Every tool's input schema is self-describing to an MCP client (name, type, and description per field) — the notes below cover the ones worth knowing up front.

- **`booking_search_destinations`/`tripadvisor_search`** are the required first step before `booking_search_hotels`/`tripadvisor_search_restaurants`/`tripadvisor_search_attractions` — those need a resolved `dest_id`/`geo_id`, not a place name.
- **`booking_search_car_rentals`** takes a plain place name (`location`) — it resolves coordinates internally via Booking.com's own location search before calling the car-rental endpoint, so no lat/lng is needed from the caller.
- **`tripadvisor_search`'s response is intentionally raw**, not extracted — see Data notes.
- Every tool with a `currency` parameter accepts any ISO 4217 code; each platform's own default (GBP for Klook, USD elsewhere) applies when omitted.

### Output

Every tool returns its underlying Actor's JSON response as a single text content block. Real result (trimmed), `booking_search_destinations` with `query: "Bangkok"`:

```json
{
    "destinations": [
        { "destId": -3414440, "name": "Bangkok", "subtitle": "Thailand" },
        { "destId": 2310, "name": "Downtown Bangkok", "subtitle": "Bangkok, Thailand" },
        { "destId": 21, "name": "Suvarnabhumi Airport", "subtitle": "Bangkok, Thailand" }
    ]
}
```

`getyourguide_check_availability` with `activity_id: "489945"`, `date: "2026-09-15"`, `adults: 2` (trimmed):

```json
{
    "success": true,
    "options": [
        {
            "optionId": 902997,
            "title": "Rafting Only Adventure with Meeting Point (No ATV)",
            "slots": [{ "startTime": "2026-09-15T09:00:00+0800", "totalPrice": { "price": 41.24, "currency": "USD" } }]
        }
    ]
}
```

A failed call returns `isError: true` with the underlying Actor's own error message in the text block — the raw error, not a generic wrapper message, so an agent can see exactly what failed (e.g. a bad id, a missing required field).

### Data notes

- **Booking.com's destination-search response has no flat `dest_id` field at all** — the raw payload is a deeply nested UI-component tree (Booking's own internal "Saba" framework), with the actual location id buried at `<entry>.props.actions[0].props.location.locationId` inside `core.OnTap` nodes. `booking_search_destinations` walks that tree and returns a clean `{destId, name, subtitle}` list instead of requiring the agent to parse it — confirmed live against the underlying Actor's own documented example (`-3414440` for Bangkok).
- **TripAdvisor's search response is left as raw pass-through, deliberately.** Its `geo_id` (found at `route.params.geoId`) is not co-located with the destination's display name the way Booking.com's is — TripAdvisor uses a normalized, GraphQL-style structure where the name lives in a separately keyed object elsewhere in the same document, connected only by an opaque reference string. Full graph-resolution extraction was judged disproportionate effort for the value gained; the tool's description instead tells the calling model exactly where to find `geoId` in the raw JSON, which a capable agent can parse directly.
- **Booking.com's car-rental search needs resolved coordinates, not a place name** — `booking_search_car_rentals` does the location-resolution step internally (first match wins) so the caller only supplies a plain name.
- **A Standby Actor's own server code cannot see or forward the calling client's Apify token** — confirmed live: Apify's Standby gateway strips the `Authorization` header (and any `?token=` query param) before a request reaches the container, using it only to gate access to this Actor's own Standby endpoint. Because of this, tool calls go out to the four wrapped Actors using a token this Actor's own owner holds, not the caller's — see Pricing for what that means for cost.

### Pricing

Pay-per-event, billed only on a successful call, two tiers depending on which platform a tool talks to:

| Event | Tools | Why |
| ----- | ----- | --- |
| `tool-call` | `booking_*`, `tripadvisor_*` | The wrapped Actor calls its upstream directly, no residential proxy |
| `tool-call-proxy` | `klook_*`, `getyourguide_*` | The wrapped Actor routes through Apify's residential proxy pool to reach its upstream — that cost is absorbed here rather than passed through as a separate charge |

Rates are tiered by your Apify plan (Free/Bronze/Silver/Gold/Platinum/Diamond get progressively cheaper rates) — see the Actor's Pricing tab for the exact current rate per tier. This is the only charge for a tool call — the four wrapped Actors' own compute/proxy cost is absorbed on this Actor's own account (see Data notes), not billed separately to you.

### Known limitations

- **No booking/checkout tools.** Every tool wraps a guest-accessible, read-only search/browse/pricing endpoint from its underlying Actor — no login flow, cart, or payment/booking submission.
- **Requires an Apify account and token even for a single tool call** — there's no anonymous or shared-credential mode; Apify's own Standby gateway enforces this before a request ever reaches this server.
- **A tool call fails if the underlying Actor is temporarily unreachable or rate-limited** (e.g. residential-proxy IP churn on the wrapped Actor's side) — the raw error surfaces in the tool result rather than being retried automatically.
- This is an unofficial, reverse-engineered integration on top of four independently reverse-engineered Actors, not affiliated with or endorsed by Klook, Booking.com, Tripadvisor, or GetYourGuide. Behavior may change if any of the four platforms change their APIs.

Found a bug or have a feature request? Use the Issues tab on this Actor's page.

# Actor input Schema

## Actor input object example

```json
{}
```

# Actor output Schema

## `api` (type: `string`):

This Actor doesn't write to a dataset — it's a Model Context Protocol server, and every tool call response is returned directly over HTTP by its Standby web server at POST /mcp. See the README for the full tool list and how to connect an MCP client.

# 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("romy/travel-tools-mcp").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("romy/travel-tools-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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 romy/travel-tools-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,romy/travel-tools-mcp"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/FXekC6PNnx8fdTVIE/builds/4zsk9Zik2ypt8t1Jz/openapi.json