---
title: "Connect Boulevard to ChatGPT: Manage Bookings and Client Data"
slug: connect-boulevard-to-chatgpt-manage-bookings-and-client-data
date: 2026-11-16
author: Sidharth Verma
categories: ["AI & Agents"]
excerpt: "Learn how to connect Boulevard to ChatGPT using a managed MCP server. Execute complex booking workflows, manage clients, and query schedules using natural language."
tldr: "Generate a secure, auto-updating MCP server for Boulevard using Truto. Connect it to ChatGPT to let your AI agents query client data, reschedule appointments, and manage location bookings via natural language."
canonical: https://truto.one/blog/connect-boulevard-to-chatgpt-manage-bookings-and-client-data/
---

# Connect Boulevard to ChatGPT: Manage Bookings and Client Data


If you need to connect Boulevard to ChatGPT so your AI agents can manage salon and spa bookings, query client histories, and orchestrate staff schedules, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between ChatGPT's tool calls and Boulevard's complex GraphQL architecture. You can either spend weeks building and maintaining this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on [connecting Boulevard to Claude](https://truto.one/connect-boulevard-to-claude-handle-orders-and-business-reports/) or explore our broader architectural overview on [connecting Boulevard to AI Agents](https://truto.one/connect-boulevard-to-ai-agents-sync-staff-and-schedule-workflows/).

Giving a Large Language Model (LLM) read and write access to an enterprise scheduling platform like Boulevard is a massive engineering challenge. You must handle sequenced GraphQL mutations, complex bookable items, cart selections, and strict staff service rules. Every time you need to expose a new capability, a custom server requires manual code updates and redeployments. 

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Boulevard, connect it natively to ChatGPT, and execute complex booking and client workflows using natural language.

> Stop writing boilerplate GraphQL integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Boulevard API

A custom MCP server is essentially a self-hosted API integration layer. While the open MCP standard provides a predictable JSON-RPC interface for LLMs, implementing it against Boulevard's highly specific scheduling API is exceptionally painful.

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 Boulevard, you own the entire API lifecycle. Here are the specific integration challenges you will face:

### Heavily Sequenced GraphQL Mutations
Boulevard operates on a GraphQL foundation where creating a full appointment is rarely a single API call. If a user tells ChatGPT, "Book Sarah for a haircut with John tomorrow at 2 PM," a custom integration must choreograph multiple operations:
1. Create the booking skeleton (`bookingCreate`).
2. Attach the specific service (`bookingAddService`).
3. Assign the staff member to that service (`bookingServiceSetStaff`).
4. Finalize delivery methods and complete the booking (`bookingComplete`).

If your MCP server does not expose these as strictly typed, schema-validated tools, the LLM will hallucinate invalid GraphQL variables, resulting in failed bookings or orphaned data.

### Cart Selections and Idempotency
Boulevard relies heavily on cart mechanics and idempotency keys to prevent duplicate charges or double bookings. When adjusting a cart's selected bookable items, existing reservations might be invalidated if the guest, staff variant, or option IDs change. Your MCP integration layer must strictly validate these payload changes before passing them to the Boulevard API to avoid corrupting a location's schedule.

### Rate Limits and Pagination Cursors
Boulevard enforces strict rate limits. Truto's proxy architecture passes standard rate limit information directly to the caller via HTTP response headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. Truto does not absorb, throttle, or automatically retry on HTTP 429 errors. Your MCP client (or the underlying AI agent framework) is completely responsible for handling backoff and retry logic when limits are exceeded. Furthermore, Boulevard list endpoints use cursor-based pagination. You must explicitly instruct the LLM to pass `next_cursor` strings back and forth without attempting to decode or modify them.

## Step 1: Create the Boulevard MCP Server

To connect ChatGPT to Boulevard, we first need to generate an MCP server. Truto [derives tool definitions dynamically](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) from the Boulevard integration's resource schemas and documentation. This means only fully documented endpoints are exposed, acting as an [AI quality gate](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/).

You can create this server in two ways: via the Truto User Interface, or programmatically via the REST API.

### Method A: Via the Truto UI

1. Log into your Truto dashboard and navigate to **Integrated Accounts**.
2. Select your connected Boulevard account (or connect one via the standard OAuth flow).
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Give your server a name (e.g., "ChatGPT Boulevard Booking System").
6. Select your configuration. For instance, you can restrict the server to specific tags (e.g., "appointments", "clients") or specific HTTP methods (e.g., "read", "write").
7. Click **Create** and copy the generated MCP server URL. It will look like `https://api.truto.one/mcp/<token>`.

### Method B: Via the Truto API

If you are building an application that dynamically provisions AI agents for your customers, you can generate this server programmatically. 

Make a `POST` request to the `/integrated-account/:id/mcp` endpoint:

```bash
curl -X POST https://api.truto.one/integrated-account/<INTEGRATED_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer <YOUR_TRUTO_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ChatGPT Boulevard Booking System",
    "config": {
      "methods": ["read", "write"],
      "tags": ["appointment", "client", "staff"]
    }
  }'
```

The response will return your server details:

```json
{
  "id": "mcp_srv_9x8y7z",
  "name": "ChatGPT Boulevard Booking System",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
}
```

This single URL contains a cryptographically hashed token that routes the LLM directly to your specific Boulevard instance. Treat this URL like a secret.

## Step 2: Connect the MCP Server to ChatGPT

Now that you have the Truto MCP URL, you must register it with your ChatGPT environment. You can do this via the ChatGPT desktop/web application, or via a manual SSE configuration file if you are running a custom OpenAI-compatible agent framework locally.

### Method A: Via the ChatGPT UI

If you are using a ChatGPT Pro, Plus, Business, Enterprise, or Education account, you can add the connector directly:

1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode** (MCP support requires this toggle).
3. Under **MCP servers / Custom connectors**, click to add a new server.
4. **Name:** Enter a recognizable label (e.g., "Boulevard via Truto").
5. **Server URL:** Paste the URL you generated in Step 1 (`https://api.truto.one/mcp/<token>`).
6. Click **Save**.

ChatGPT will immediately perform a JSON-RPC `initialize` handshake, discover the tools, and make them available in your chat interface.

### Method B: Via Manual Config File (SSE Transport)

If you are running a local orchestrator or utilizing an environment that requires a standard MCP configuration file (such as Claude Desktop or Cursor), you can connect to the Truto server using the official Server-Sent Events (SSE) wrapper.

Add the following configuration to your `mcp_config.json`:

```json
{
  "mcpServers": {
    "boulevard-prod": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
      ]
    }
  }
}
```

This utilizes the `@modelcontextprotocol/server-sse` package to translate standard standard I/O into the remote HTTP POST requests that Truto expects.

## Boulevard Hero Tools for AI Agents

When ChatGPT issues a `tools/list` request, Truto dynamically compiles the available integration resources into strict JSON Schema tools. Here are six high-leverage Boulevard tools you can expose to your LLM.

### list_all_boulevard_appointments

Fetches a paginated list of appointments for a specific location. It supports filtering by staff ID, start date, creation date, and cancellation status. 

**Usage Note:** Ensure the LLM provides the `locationId`. If pagination is required, instruct the model to pass the `next_cursor` value exactly as it receives it.

> "Show me all appointments scheduled for tomorrow at location ID 'loc_123'. Exclude any that have been cancelled."

### get_single_boulevard_appointment_by_id

Looks up a complete appointment record by its unique ID. This is critical for fetching deep context before executing rescheduling or cancellation workflows.

**Usage Note:** The ID must be the global node ID assigned by Boulevard.

> "Pull up the details for appointment ID 'apt_889900'. I need to see which staff member is assigned and what the current status is."

### boulevard_appointments_lookup_reschedule_times

Queries the Boulevard scheduling engine to find available appointment times on a particular date for a specific appointment ID.

**Usage Note:** This is a complex query that evaluates staff service rules, overlapping time blocks, and location hours. It requires the `appointmentId` and a target `date`.

> "Check the available schedule times for next Tuesday to reschedule appointment ID 'apt_889900'."

### create_a_boulevard_booking

Initiates a new booking skeleton. This is the first step in Boulevard's multi-step booking process. 

**Usage Note:** This mutation only requires a `locationId` to start. The AI agent must subsequently call `create_a_boulevard_booking_service` to add bookable items to this skeleton.

> "Start a new booking at the downtown location (loc_123)."

### update_a_boulevard_booking_service_staff_by_id

Assigns a specific staff member to a service item within a booking. 

**Usage Note:** Requires the service item `id` and the parent `bookingId`. This is essential when a client requests a specific stylist or technician.

> "Update the booking service ID 'svc_456' on booking 'bkg_789' to be handled by staff member ID 'stf_99'."

### list_all_boulevard_clients

Retrieves a list of clients associated with the business. Supports filtering by email, name, phone, external ID, and primary location.

**Usage Note:** Excellent for resolving identities when a customer interacts with a chatbot. The LLM can fuzzy-match names or look up exact phone numbers.

> "Search the client directory for someone named 'Sarah Jenkins' or anyone with the phone number 555-0199."

For the complete inventory of available Boulevard tools and their detailed query and body schemas, visit the [Boulevard Integration Page](https://truto.one/integrations/detail/boulevard).

## Workflows in Action

Here is how an AI agent uses these tools in sequence to solve real-world scheduling problems.

### Scenario 1: Front-Desk Agent Managing Rescheduling

A customer sends a message stating they cannot make their appointment and need to move it to a specific date. The AI agent must locate the appointment, verify availability, and execute the change.

> "I'm currently booked for a haircut tomorrow under my ID 'apt_889900', but I need to reschedule to next Wednesday. What times are available in the afternoon?"

**Execution Steps:**
1. **Verify State:** The agent calls `get_single_boulevard_appointment_by_id` with `{ id: "apt_889900" }` to confirm the appointment is active and not already cancelled.
2. **Check Availability:** The agent calls `boulevard_appointments_lookup_reschedule_times` passing the appointment ID and the target date for "next Wednesday".
3. **Format Output:** The LLM receives the array of available time blocks, filters them for "afternoon" hours based on the user's prompt, and formats a friendly text response to the user.

```mermaid
sequenceDiagram
    participant User
    participant GPT as ChatGPT
    participant Truto
    participant Boulevard

    User->>GPT: "Reschedule my appointment..."
    GPT->>Truto: call get_single_boulevard_appointment_by_id
    Truto->>Boulevard: GraphQL Query (appointment)
    Boulevard-->>Truto: Appointment Status & Details
    Truto-->>GPT: JSON Result
    GPT->>Truto: call boulevard_appointments_lookup_reschedule_times
    Truto->>Boulevard: GraphQL Mutation (appointmentRescheduleAvailableTimes)
    Boulevard-->>Truto: Array of available times
    Truto-->>GPT: JSON Result
    GPT-->>User: "I have 1:00 PM, 2:30 PM, and 4:00 PM available. Which do you prefer?"
```

### Scenario 2: Concierge Identifying Clients and Adding Notes

A concierge AI assistant needs to flag a client profile based on a customer service interaction so the front desk is aware of specific preferences before the client arrives.

> "Find the client profile for sarah.jenkins@example.com and add a note to her account stating she requires fragrance-free products for her next visit."

**Execution Steps:**
1. **Identify Client:** The agent calls `list_all_boulevard_clients` with `{ email: "sarah.jenkins@example.com" }` to retrieve the unique `clientId`.
2. **Extract ID:** The LLM parses the JSON response and extracts the ID (e.g., `cli_999`).
3. **Add Note:** The agent calls `create_a_boulevard_client_note` with `{ clientId: "cli_999", text: "Client requires fragrance-free products for all services." }`.
4. **Confirmation:** Truto executes the GraphQL mutation, returning a success payload, and ChatGPT confirms the action to the user.

## Security and Access Control

Exposing an enterprise scheduling system to an AI agent requires strict guardrails. Truto's MCP architecture provides several layers of access control configured directly on the token:

*   **Method Filtering:** Use `config.methods` during server creation to restrict the AI to specific HTTP methods. Passing `["read"]` ensures the LLM can only query data (lists, gets) and strictly prevents accidental creations, updates, or deletions.
*   **Tag Filtering:** Use `config.tags` to limit the server's scope to specific functional areas. For example, passing `["client"]` ensures the AI can access client records but has zero visibility into payroll, reports, or financial data.
*   **API Token Authentication:** By default, possessing the MCP URL grants access. For enhanced security, set `require_api_token_auth: true`. The client (or agent framework) must then pass a valid Truto API token in the `Authorization` header on every request.
*   **Time-To-Live Expiration:** Set an `expires_at` ISO datetime when generating the server. Once the timestamp passes, the server URL automatically invalidates and a cleanup job removes the configuration, making it perfect for temporary contractor access or limited-time testing.

## Orchestrating Complex Workflows with Ease

Connecting ChatGPT to Boulevard requires more than just pushing data; it demands an intelligent orchestration layer capable of translating natural language intents into highly sequenced, strictly typed GraphQL operations. Building this integration in-house means writing custom schema parsers, managing OAuth flows, and manually updating code every time a new Boulevard endpoint is needed.

By leveraging a managed MCP server via Truto, you instantly bridge the gap between AI frameworks and complex enterprise APIs. Your agents gain real-time, secure access to bookings, staff schedules, and client data, while you retain total control over permissions and access limits.

> Ready to automate your Boulevard workflows? Connect with our team to see how Truto's MCP servers can accelerate your AI agent development.
>
> [Talk to us](https://truto.one/book-a-demo/)
