---
title: "Connect GuestPoint to Claude: Manage Rates, Extras, and Bookings"
slug: connect-guestpoint-to-claude-manage-rates-extras-and-bookings
date: 2026-06-27
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect GuestPoint to Claude using a managed MCP server. Execute complex property management workflows, sync rates, and automate bookings directly through natural language."
tldr: "Connect GuestPoint to Claude via a managed MCP server to automate hospitality workflows. This guide covers the engineering reality of PMS APIs, how to generate a secure MCP endpoint via UI or API, and how to execute multi-step booking operations."
canonical: https://truto.one/blog/connect-guestpoint-to-claude-manage-rates-extras-and-bookings/
---

# Connect GuestPoint to Claude: Manage Rates, Extras, and Bookings


If you need to give your AI agents read and write access to property management data, you need a reliable integration layer. If your team uses ChatGPT, check out our guide on [connecting GuestPoint to ChatGPT](https://truto.one/connect-guestpoint-to-chatgpt-search-availability-and-book-rooms/) or explore our broader architectural overview on [connecting GuestPoint to AI Agents](https://truto.one/connect-guestpoint-to-ai-agents-sync-rates-and-automate-bookings/).

Giving a Large Language Model (LLM) access to a Property Management System (PMS) like GuestPoint is fundamentally different from connecting to a generic CRM. You are dealing with highly constrained physical inventory, complex date-math, dynamic pricing, and deeply nested reservation payloads. Building this integration yourself means hand-writing JSON schemas for every endpoint, managing stateful authentication, and handling edge cases specific to hospitality software.

Instead of building and maintaining custom infrastructure, you can use Truto to dynamically generate a secure [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This managed server acts as a translation layer, taking Claude's tool calls and securely executing them against the GuestPoint API in real time. 

This guide breaks down the engineering realities of the GuestPoint API, how to generate a secure MCP server via the UI or API, and how to execute multi-step hospitality workflows directly from Claude.

## The Engineering Reality of the GuestPoint API

A custom MCP server is a self-hosted API gateway that translates an LLM's JSON-RPC 2.0 messages into vendor-specific HTTP requests. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against specific B2B APIs is punishing.

If you decide to [build a custom MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/) for GuestPoint, you own the entire API lifecycle. You must write and maintain massive JSON schemas for complex endpoints, handle token lifecycles, and deal with the PMS's specific architectural quirks. Here is exactly what makes integrating with GuestPoint difficult:

**Nested Reservation Architecture**
A reservation in GuestPoint is not a flat object. It is a hierarchical payload requiring a `PropertyId`, a specific `ChannelCode`, and an array of `RoomStays`. Each room stay requires its own nested array of guest details, rate plans, and date allocations. If you expose raw endpoints to an LLM without strict schema guidance, the model will almost certainly hallucinate payload structures, leading to `400 Bad Request` errors. Truto's dynamic tool generation pulls exact body schemas from documentation records, explicitly instructing Claude on required fields and array structures.

**Two-Step Booking Validation**
You cannot reliably push a reservation directly into the booking endpoint. GuestPoint typically requires a validation step where you send a provisional payload to confirm availability, calculate final pricing, and generate a `VerificationCode`. This code must then be passed into the final reservation creation request. Building an MCP server means ensuring your LLM understands this sequential dependency. By exposing both validation and creation endpoints as separate, strongly typed tools, the model can navigate the flow correctly.

**Rate Limits and 429 Responses**
GuestPoint, like any transactional system, enforces rate limits on property queries. When you hit these limits, the API returns a `429 Too Many Requests` status. **Truto does not absorb, throttle, or automatically retry these requests.** Instead, Truto passes the HTTP 429 error directly back to the caller, mapping the upstream rate limit data into standardized IETF headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`). This architectural decision guarantees deterministic execution. Your MCP client (or orchestration layer) is entirely responsible for reading these headers and applying its own retry and exponential backoff logic.

## How to Generate a GuestPoint MCP Server

Truto [dynamically generates MCP servers](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) by reading your integrated account's configuration and documentation records. Every resource and method defined on the GuestPoint integration is mapped to a JSON Schema, which is then exposed as an MCP-compatible tool. Tools without documentation records are automatically excluded, acting as a strict quality gate.

Each MCP server is securely scoped to a single integrated account (a specific tenant's connected GuestPoint instance). You can generate the server using either the Truto dashboard or the API.

### Method 1: Generating via the Truto UI

This method is best for internal administrative usage and rapid prototyping.

1. Log into your Truto dashboard and navigate to the integrated account page for the specific GuestPoint connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration. You can apply filters to restrict the server to specific HTTP methods (e.g., `read`, `write`) or specific tags (e.g., `reservations`, `inventory`).
5. Set an optional expiration date if you want the server to self-destruct after a specific time.
6. Click Save and immediately **copy the generated MCP server URL**. You will not be able to view the raw token again.

### Method 2: Generating via the API

For production usage, you should generate MCP servers programmatically on behalf of your users. This ensures the infrastructure scales without manual intervention.

Send an authenticated `POST` request to `/integrated-account/:id/mcp` with your desired configuration.

```bash
curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Claude Booking Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["reservations", "rates"]
    }
  }'
```

The Truto API will validate that the integration has tools available, generate a cryptographically secure, hashed token, store it in distributed edge storage, and return a ready-to-use URL.

```json
{
  "id": "mcp-req-889922",
  "name": "Claude Booking Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
}
```

## How to Connect the MCP Server to Claude

Once you have your Truto MCP URL, you can plug it directly into Claude. The URL is self-contained. It handles all JSON-RPC 2.0 routing and authentication behind the scenes.

### Method A: Via the Claude UI (Settings)

If you are using Claude Desktop or Claude Web (depending on your subscription tier):

1. Copy the MCP server URL generated in the previous step.
2. In Claude, navigate to **Settings -> Integrations -> Add MCP Server**.
3. Paste the URL into the server address field and click **Add**.
4. Claude will immediately send an `initialize` handshake to the URL, discover the available tools, and map them into the current context window.

### Method B: Via Manual Config File

If you are running Claude Desktop locally for development, you can configure the MCP server using the `claude_desktop_config.json` file. Truto supports the Server-Sent Events (SSE) transport out of the box via the official `@modelcontextprotocol/server-sse` proxy.

Locate your configuration file:
- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
- Windows: `%APPDATA%\Claude\claude_desktop_config.json`

Add the following configuration, replacing `YOUR_TRUTO_MCP_URL` with the URL you generated:

```json
{
  "mcpServers": {
    "guestpoint_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "YOUR_TRUTO_MCP_URL"
      ]
    }
  }
}
```

Restart Claude Desktop. The model will read the configuration, spawn the proxy process, and connect to the GuestPoint integration.

## GuestPoint Hero Tools for Claude

Truto dynamically translates GuestPoint resources into snake_case MCP tools, deriving query and body schemas from documentation records. Below are the highest-leverage tools available for automating property management workflows.

### list_all_guest_point_properties_availabilities

This is the core inventory tool. It queries a property for available rooms, capacity, and current rate plans over a specific date range. Because PMS availability is highly volatile, agents must call this tool before attempting to build a reservation payload.

> "Check availability for property ID 'GP-405' from October 12th to October 15th for 2 adults. Give me a breakdown of the available room types and the nightly SellRate vs StrikeOutRate."

### update_a_guest_point_properties_reservation_by_id

Before creating a final booking, GuestPoint requires a validation pass. This tool submits a provisional reservation payload to confirm that the requested inventory is still available and calculates the final pricing total. It returns a `VerificationCode` that must be used in the final creation step.

> "Validate a reservation for property 'GP-405' for a Deluxe King room from Oct 12 to Oct 15 for 2 adults. Please return the calculated ReservationTotal and the VerificationCode."

### create_a_guest_point_properties_reservation

Executes the final booking. This tool takes the validated payload, along with the `VerificationCode` and guest details, and commits the reservation to the GuestPoint database. The LLM handles constructing the complex `RoomStays` array based on the provided JSON Schema.

> "Proceed with booking the Deluxe King room at 'GP-405' using the VerificationCode 'V-99381'. The guest is John Doe, and payment will be settled at the desk. Confirm the final ConfNum once successful."

### list_all_guest_point_properties_bestavailablerates

This tool pulls the best available rate for a specific property across a date range. It returns the absolute cheapest rate for each day, making it perfect for revenue managers looking to analyze baseline pricing or dynamically update marketing materials.

> "Pull the best available rates for property 'GP-405' for the entire month of November. Identify the cheapest day to stay and the most expensive day."

### list_all_guest_point_exchangerates

Many hospitality businesses cater to international travelers. This tool allows the agent to fetch the real-time exchange rate defined within the GuestPoint system to provide accurate, localized pricing quotes to prospective guests.

> "Get the current exchange rate from USD to EUR as defined in the GuestPoint system, and use it to estimate the cost of a $400 stay in Euros."

### create_a_guest_point_properties_extra

Retrieves eligible extras and add-ons (e.g., late checkout, breakfast packages, spa access) available for a specific date range and room combination. This is critical for upselling workflows.

> "Fetch the available extras for a booking at 'GP-405' checking in tomorrow. I specifically want to know the price for the 'Breakfast Bundle' and if it has a MaxItems limit per room."

To view the complete inventory of available tools, required parameters, and JSON schemas, view the [GuestPoint integration page](https://truto.one/integrations/detail/guestpoint).

## Workflows in Action

With the MCP server connected, Claude transitions from a passive chatbot into an active participant in your property management operations. By chaining multiple tool calls together, the LLM can execute workflows that previously required humans to click through complex UI screens.

### Scenario 1: Front Desk Agent Booking a Walk-in

When a guest walks into the lobby looking for a room, speed is critical. A front desk agent can use Claude to instantly find availability, calculate pricing, and book the room using natural language.

> "I have a walk-in guest looking for a room for tonight and tomorrow night (2 adults). Find me the cheapest available room at our property (GP-101), validate the pricing, and book it under 'Sarah Jenkins'. Send me the confirmation number."

**How Claude executes this:**
1. Calls `list_all_guest_point_properties_availabilities` with the current dates and `Adults=2` to find open inventory.
2. Identifies the cheapest room type from the returned array.
3. Calls `update_a_guest_point_properties_reservation_by_id` with a provisional payload to lock the price and generate a `VerificationCode`.
4. Calls `create_a_guest_point_properties_reservation` using the `VerificationCode` and guest details to finalize the booking.
5. Reads the `ConfNum` from the response and outputs the confirmation to the agent.

```mermaid
sequenceDiagram
    participant User as Front Desk Agent
    participant Claude as Claude Desktop
    participant TrutoMCP as Truto MCP Server
    participant GuestPoint as GuestPoint API

    User->>Claude: "Find cheapest room for tonight..."
    Claude->>TrutoMCP: tools/call (list_all_guest_point_properties_availabilities)
    TrutoMCP->>GuestPoint: GET /properties/GP-101/availabilities
    GuestPoint-->>TrutoMCP: 200 OK (Rates and Inventory)
    TrutoMCP-->>Claude: JSON-RPC Result
    Claude->>TrutoMCP: tools/call (update_a_guest_point_properties_reservation_by_id)
    TrutoMCP->>GuestPoint: PUT /properties/GP-101/reservations/validate
    GuestPoint-->>TrutoMCP: 200 OK (VerificationCode: 8829)
    TrutoMCP-->>Claude: JSON-RPC Result
    Claude->>TrutoMCP: tools/call (create_a_guest_point_properties_reservation)
    TrutoMCP->>GuestPoint: POST /properties/GP-101/reservations
    GuestPoint-->>TrutoMCP: 200 OK (ConfNum: GP-99120)
    TrutoMCP-->>Claude: JSON-RPC Result
    Claude-->>User: "Room booked. Confirmation: GP-99120"
```

### Scenario 2: Revenue Manager Analyzing Rate Spreads

A revenue manager wants to understand baseline pricing for the upcoming holiday season to adjust strategy. Instead of running slow, manual reports, they can query the data agentically.

> "Pull the best available rates for property 'GP-101' for December 20th through January 2nd. Calculate the average nightly rate in USD, and then convert that total into GBP using the current system exchange rates."

**How Claude executes this:**
1. Calls `list_all_guest_point_properties_bestavailablerates` for the requested date range.
2. Iterates through the returned array, extracting the cheapest rate for each day, and calculates the mathematical average in its reasoning context.
3. Calls `list_all_guest_point_exchangerates` with `from_currency=USD` and `to_currency=GBP`.
4. Applies the returned multiplier to the average rate and outputs the financial summary to the revenue manager.

## Security and Access Control

Exposing an enterprise PMS directly to an LLM introduces massive risk if not secured properly. Truto provides strict governance mechanisms at the MCP server level to ensure agents only execute authorized actions.

*   **Method Filtering**: You can lock down an MCP server by specifying `config.methods`. Passing `["read"]` ensures the server will only generate tools for `GET` and `list` endpoints. If the LLM attempts to hallucinate a `create` tool, the MCP server will reject the protocol request outright.
*   **Tag Filtering**: You can scope access by functional domain. Passing `config.tags: ["rates"]` ensures the server only exposes tools related to pricing, entirely removing access to sensitive guest profile data or internal configuration endpoints.
*   **API Token Authentication**: By default, possession of the cryptographic MCP URL grants access. For higher-security environments, you can set `require_api_token_auth: true`. This forces the client to pass a valid Truto API token in the HTTP `Authorization` header, providing a secondary authentication layer.
*   **Automatic Expiration**: When generating short-lived access for contractors or temporary automated scripts, you can pass an ISO datetime to `expires_at`. Truto's edge infrastructure will automatically terminate the server and flush the cryptographic tokens exactly at the expiration time, preventing stale access.

## Stop Building Boilerplate

Connecting Claude to GuestPoint does not require months of infrastructure engineering. You do not need to write extensive JSON schemas, manage stateful OAuth lifecycles, or build complex proxy layers to handle nested reservation logic.

By leveraging Truto's dynamic MCP server generation, you map the complexities of the GuestPoint API into standardized, LLM-ready tools instantly. Your engineers can focus on building sophisticated agentic workflows, while the integration layer handles the protocol translation, pagination, and API normalization.

> Stop wasting engineering cycles on custom connectors. Use Truto to generate secure, managed MCP servers for GuestPoint and 100+ other B2B platforms instantly.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)