Connect Now Book It to ChatGPT: Manage Bookings, Sales & Customers

If you want to connect Now Book It to ChatGPT so your AI agents can manage restaurant reservations, modify table assignments, sell gift cards, and track customer profiles, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and the Now Book It REST API.

If your team uses Claude, check out our guide on connecting Now Book It to Claude or explore our broader architectural overview on connecting Now Book It to AI Agents.

Giving a Large Language Model (LLM) read and write access to a live venue management platform is an engineering risk. Restaurant inventory is highly stateful - a booking is not just a database row, it represents physical space, timing constraints, and table layouts. You either spend weeks building, hosting, and maintaining a custom MCP server to translate LLM JSON arguments into Now Book It's specific payload structures, or you use a managed infrastructure layer.

This guide breaks down exactly how to use Truto to generate a secure, authenticated MCP server for Now Book It, connect it natively to ChatGPT, and execute complex hospitality workflows using natural language.

Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds. :::

The Engineering Reality of the Now Book It API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against vendor APIs is painful. If you decide to build a custom MCP server for Now Book It, you own the entire API lifecycle.

Here are the specific integration challenges that break standard CRUD assumptions when working with Now Book It:

Segmented Booking Modifications

In a standard REST API, updating a record usually involves a single PATCH or PUT request with the modified fields. Now Book It separates booking modifications into hyper-specific operational endpoints. If a party of two calls to say they are bringing two extra guests, you do not just update the booking object. You must explicitly call the pax (party size) update endpoint. Because a larger party might not fit at the original table, you often have to orchestrate a subsequent call to the tables update endpoint, explicitly managing the allowTableBookingConflict boolean to prevent double-booking physical floor space. Your MCP schemas must strictly define these separate actions so the LLM knows to sequence them correctly.

Date vs Window Filtering

The Now Book It API employs distinct paradigms for temporal filtering. When listing bookings, if an agent wants to filter by a date range, they must provide exactly either StartDate and EndDate (to query by the actual reservation time) OR UpdatedFromDate and UpdatedToDate (to query by modification timestamps). Mixing these parameters causes request failures. Generating static MCP tool schemas requires injecting descriptions that force the LLM to choose one pair or the other.

Asynchronous Booking State

Certain booking updates in Now Book It are asynchronous. Calling the async booking update endpoint returns a 202 Accepted style response with the requested payload, but the backend system queues the update for processing against the live floor plan. The LLM cannot assume the update succeeded purely based on the HTTP response; it must either rely on webhook callbacks (which are difficult to route back into an active LLM context window) or explicitly re-query the booking state later.

Strict Gift Card State Machines

Gift cards in Now Book It follow a strict state machine. A card moves from issued to redeemed to expired or cancelled. You cannot randomly mutate a gift card's balance. You must execute explicit redemption or cancellation endpoints. If an LLM attempts a redemption transaction, the tool must enforce the required cardNumber and amount properties precisely, as failures here directly impact venue revenue.

Handling Rate Limits and Retry Logic

When connecting AI agents to production systems, rate limits are the silent killer of autonomous workflows. LLMs are fast and can easily fire off dozens of parallel tool calls (e.g., iterating through pagination or searching availability across multiple days) that overwhelm upstream APIs.

It is critical to understand the architectural boundary here: Truto does not retry, throttle, or apply backoff on rate limit errors.

When the Now Book It API returns an HTTP 429 Too Many Requests, Truto passes that exact error directly back to the calling client (ChatGPT). Truto automatically normalizes the upstream rate limit information into standardized headers per the IETF spec:

• ratelimit-limit: The total requests allowed in the current window.
• ratelimit-remaining: The number of requests remaining.
• ratelimit-reset: The timestamp when the quota resets.

Your LLM framework or calling application is 100% responsible for interpreting this 429 response, parsing the headers, and implementing the appropriate backoff/retry logic. Do not expect the MCP server to absorb the load and automatically queue requests.

Generating the Now Book It MCP Server

Truto dynamically generates MCP tools based on the active Now Book It integration's resource configuration and documentation schemas. Each MCP server is securely scoped to a single connected tenant account, meaning the URL inherently authenticates requests for that specific venue.

You can create an MCP server via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

1. Navigate to your Truto dashboard.
2. Go to the Integrated Accounts page and select your active Now Book It connection.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restrict to read methods only, set an expiration date).
6. Copy the generated secure MCP Server URL (e.g., https://api.truto.one/mcp/a1b2c3...).

Method 2: Via the API

For platform engineers generating MCP endpoints dynamically for end-users, you can provision servers via a single API call.

// POST /integrated-account/:id/mcp
const response = await fetch('https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_TRUTO_API_TOKEN',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Now Book It Agent Access - Front Desk",
    config: {
      methods: ["read", "write"],
      tags: ["bookings", "schedules"]
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});
 
const data = await response.json();
console.log(data.url); // The MCP server URL to pass to the client

The returned URL contains a cryptographically hashed token that securely identifies the tenant and enforces the specified configuration constraints.

Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, providing ChatGPT with full access to Now Book It takes less than a minute. You can connect it via the ChatGPT interface or via local configuration for desktop clients.

Option A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings.
2. Select Connectors (or Apps -> Advanced settings -> Developer mode depending on your tier).
3. Click Add custom connector or Add MCP Server.
4. Provide a name (e.g., "Now Book It Ops").
5. Paste the Truto MCP URL into the Server URL field.
6. Click Add.

ChatGPT will immediately perform an MCP handshake, calling the initialize and tools/list RPC methods to discover the available Now Book It operations.

Option B: Via Local Config File (Desktop Clients)

If you are running custom agentic frameworks, Claude Desktop, or Cursor, you can mount the remote server using the official SSE transport.

{
  "mcpServers": {
    "now-book-it": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/YOUR_SECURE_TOKEN"
      ]
    }
  }
}

Hero Tools for Now Book It

When Truto generates the tool list, it converts integration resources into highly descriptive snake_case tool names, merging query and body parameters into a flat JSON Schema.

Here are the highest-leverage tools available for Now Book It.

list_all_now_book_it_bookings_schedules

This is the most critical endpoint for front-of-house operations. It returns available booking schedule time slots filtered by date range and party size. If you pass a BookingId, it returns alternative timings for an existing reservation.

"Check the schedule availability for a party of 4 this Friday evening. Omit the end time so we get the whole evening's slots."

create_a_now_book_it_booking

The core write operation. It pushes a new reservation directly into the venue system. Note that numOfPeople is strictly required. The agent must collect all required details from the user before executing this tool.

"Create a new booking under the name John Doe for the 7:00 PM slot we just found. Party size is 4."

now_book_it_bookings_update_pax

Modifies the party size for a specific booking_id. This tool isolates the pax update logic from other booking metadata, returning the updated bookingRef and status.

"Update booking ID 98234. They just called and added two more people to their party, so the new pax is 6."

now_book_it_bookings_update_tables

Assigns or re-assigns physical tables to a reservation. Crucially, this requires the allowTableBookingConflict boolean flag, which the LLM must set carefully based on user instruction to avoid double-seating.

"Move booking ID 98234 to tables 12 and 13. Set the table conflict flag to false, we don't want to double-book."

list_all_now_book_it_gift_cards

Retrieves gift card states. Essential for processing payments or verifying validity before a customer arrives. Filters by SKU, issue dates, and status (cancelled, redeemed, expired).

"Look up the gift card with card number GC-99482 and tell me its current balance and status."

now_book_it_gift_cards_redeem

Executes a financial transaction to deduct a balance from a gift card. The agent must strictly supply the cardNumber and the amount to redeem.

"Redeem $50.00 from gift card GC-99482 to cover the deposit for their upcoming reservation."

Note: This is just a selection of the highest-leverage capabilities. Truto automatically generates tools for customers, sales, webhooks, and bulk updates. For the complete tool inventory and schema details, visit the Now Book It integration page.

Workflows in Action

AI agents shine when orchestrating multi-step workflows across segmented APIs. Here is how ChatGPT handles complex venue operations using the generated tools.

Workflow 1: The Walk-In Modification

A host needs to update a reservation because a party arrived with more people than expected, requiring a table shift.

"Booking ID 5521 just walked in, but they have 6 people instead of 4. Increase their party size, then check available tables and move them to table 40. Make sure not to double book it."

Agent Execution Trace:

1. get_single_now_book_it_booking_by_id: Fetches the current booking state to verify details and current table assignments.
2. now_book_it_bookings_update_pax: Sends { "booking_id": "5521", "pax": 6 } to increase the party size.
3. list_all_now_book_it_bookings_tables: Queries available tables for the current duration to verify Table 40 is open.
4. now_book_it_bookings_update_tables: Executes the shift, sending { "booking_id": "5521", "tables": ["40"], "allowTableBookingConflict": false }.

The user receives confirmation that the party size was successfully updated and the table was safely reassigned without conflicts.

sequenceDiagram
    participant User as User Prompt
    participant ChatGPT as ChatGPT Client
    participant MCP as Truto MCP Router
    participant Upstream as Now Book It API

    User->>ChatGPT: "Increase pax to 6 and move to Table 40"
    ChatGPT->>MCP: Call now_book_it_bookings_update_pax (pax: 6)
    MCP->>Upstream: PATCH /bookings/5521/pax
    Upstream-->>MCP: Success (200 OK)
    MCP-->>ChatGPT: Tool Result
    ChatGPT->>MCP: Call now_book_it_bookings_update_tables
    MCP->>Upstream: PATCH /bookings/5521/tables
    Upstream-->>MCP: Success (200 OK)
    MCP-->>ChatGPT: Tool Result
    ChatGPT-->>User: "Updated to 6 guests and moved to Table 40."

Workflow 2: Deposit and Gift Card Verification

A concierge is setting up a large event and needs to verify and charge a deposit against a provided gift card.

"Check the status of gift card number 8829-1022. If it is active and has at least $100, redeem $100 from it and then update the status of booking ID 7712 to confirmed."

Agent Execution Trace:

1. list_all_now_book_it_gift_cards: Filters by cardNumber to inspect the status and remaining balance.
2. LLM Logic: Evaluates the JSON response. If status === 'active' and amount >= 100, proceed.
3. now_book_it_gift_cards_redeem: Executes the financial deduction.
4. now_book_it_bookings_bulk_update: Updates the booking status using { "booking_id": "7712", "status": "confirmed" }.

The agent securely orchestrates a read-evaluate-write loop, ensuring a financial transaction only occurs if conditions are met, before updating the venue floor status.

Security and Access Control

When putting venue operations in the hands of an LLM, strict access controls are mandatory. Truto provides several architectural layers to lock down your MCP servers:

• Method Filtering: Limit the MCP server to specific HTTP verbs. Pass methods: ["read"] during creation to restrict the LLM entirely to GET and LIST tools. It will be physically impossible for the agent to alter a booking or redeem a gift card.
• Tag Filtering: Restrict tools by functional domain. Pass tags: ["gift_cards"] to generate a server that can only interact with financial tools, keeping the agent away from operational schedules and customer profiles.
• Automatic Expiration: Supply an expires_at timestamp. Truto uses distributed edge storage and durable alarms to automatically destroy the token and flush the configuration when time runs out, perfect for temporary contractor access.
• Double Authentication: Enable require_api_token_auth: true. The URL token alone will no longer be enough; the client must also supply a valid Truto API bearer token in the headers, adding a secondary identity check for zero-trust environments.

Automating hospitality systems requires precision. By leveraging a managed MCP architecture, your engineering team skips the boilerplate of parsing custom table schemas and implementing OAuth flows. Instead, you instantly provide AI models with secure, strictly-defined access to Now Book It's live floor data, turning natural language into executing venue operations.