Skip to content

Connect Boulevard to ChatGPT: Manage Bookings and Client Data

Learn how to connect Boulevard to ChatGPT using a managed MCP server. Execute complex booking workflows, manage clients, and query schedules using natural language.

Sidharth Verma Sidharth Verma · · 9 min read
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. 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 or explore our broader architectural overview on connecting Boulevard to AI Agents.

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.

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 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 from the Boulevard integration's resource schemas and documentation. This means only fully documented endpoints are exposed, acting as an AI quality gate.

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:

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:

{
  "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:

{
  "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.

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

FAQ

How do I connect Boulevard to ChatGPT?
You can connect Boulevard to ChatGPT by generating a Model Context Protocol (MCP) server URL via Truto. Once generated, add the URL to ChatGPT's custom connectors settings in Developer mode.
Does Truto handle Boulevard API rate limits automatically?
No. Truto passes through standard rate limit headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) directly from Boulevard. If a 429 error occurs, it is passed to the calling AI agent, which is responsible for implementing retry and backoff logic.
Can I restrict what data ChatGPT can access in Boulevard?
Yes. When generating the MCP server in Truto, you can use method filtering (e.g., 'read' only) and tag filtering to restrict the server to specific operations, ensuring ChatGPT cannot execute destructive mutations unless explicitly allowed.
Why are Boulevard API integrations difficult for AI agents?
Boulevard utilizes a complex GraphQL API where a single booking often requires multiple sequenced mutations (creating the booking, attaching services, attaching staff, setting times). Orchestrating these accurately requires strict JSON Schema enforcement.

More from our Blog