---
title: "Connect Now Book It to Claude: Sync Tables, Schedules & Gift Cards"
slug: connect-now-book-it-to-claude-sync-tables-schedules-gift-cards
date: 2026-08-24
author: Riya Sethi
categories: ["AI & Agents"]
excerpt: "Learn how to connect Now Book It to Claude using a Truto MCP server. Automate restaurant reservations, sync floor plans, and reconcile gift cards natively."
tldr: "Connect Now Book It to Claude using Truto's dynamically generated MCP servers. This guide covers API realities, setup methods, security controls, and real-world FoH automation workflows."
canonical: https://truto.one/blog/connect-now-book-it-to-claude-sync-tables-schedules-gift-cards/
---

# Connect Now Book It to Claude: Sync Tables, Schedules & Gift Cards


If your team needs to connect Now Book It to Claude to automate restaurant reservations, sync floor plan assignments, or reconcile gift card redemptions, you need a [Model Context Protocol (MCP) server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/). This server acts as the translation layer between Claude's function calls and the Now Book It REST API. You can build and maintain this infrastructure entirely in-house, or use a managed integration platform like Truto to dynamically generate a [secure, authenticated MCP server URL in seconds](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). If your team uses ChatGPT, check out our guide on [connecting Now Book It to ChatGPT](https://truto.one/connect-now-book-it-to-chatgpt-manage-bookings-sales-customers/) or explore our broader architectural overview on [connecting Now Book It to AI Agents](https://truto.one/connect-now-book-it-to-ai-agents-automate-reservations-webhooks/).

Giving a Large Language Model (LLM) read and write access to a specialized hospitality management system is an engineering challenge. You must handle complex table mapping rules, asynchronous booking updates, and domain-specific availability matrices. Every time the integration vendor updates an endpoint or deprecates a field, you have to update your server code, redeploy, and run regression tests. 

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Now Book It, [connect it natively to Claude](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/), and execute complex Front-of-House (FoH) and operations workflows using natural language.

## 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, the reality of implementing it against specialized B2B APIs is painful. Now Book It is built to handle highly stateful, concurrent restaurant operations - from managing table conflicts to processing POS sales. Its API reflects that complexity.

If you decide to [build a custom Now Book It MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), here are the specific integration challenges you will face:

**Asynchronous Booking Updates and Eventual Consistency**
Not all endpoints in the Now Book It API behave like synchronous CRUD operations. For instance, modifying a reservation via the async update endpoint returns an immediate 202 Accepted response, but the actual state change takes time to process in the backend. LLMs struggle with eventual consistency. If Claude assumes a booking is immediately updated and tries to reassign the table in the very next tool call, it will fail. Your MCP server must explicitly guide the model to either poll for the updated state or wait before executing dependent operations.

**Strict Table Conflict Management**
Assigning tables is not a simple string update. The API enforces strict validation against overlapping reservations, capacity constraints, and duration limits. If you want to force an override, you must pass specific boolean flags like `allowTableBookingConflict`. An LLM cannot guess this operational logic. A managed MCP server exposes tools with strictly defined JSON schemas that explicitly instruct the LLM on which flags to use and when.

**Complex Schedule Availability Matrices**
Querying availability is not a basic database read. The schedule endpoints require precise combinations of start dates, end dates, durations, and party sizes (pax). Omitting `BookingDateTimeEnd` triggers a full-day search, while including an existing `BookingId` alters the query to find alternative timings for a specific reservation. Mapping these nuances into a flat tool definition that Claude can reliably understand requires significant prompt engineering and schema normalization.

**Raw 429 Rate Limits and the Burden of Orchestration**
It is critical to note that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Now Book It API returns an HTTP 429 Too Many Requests error, Truto passes that error directly to the caller. We normalize the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller - whether that is your AI agent framework or Claude Desktop - is fully responsible for catching these errors and executing a retry and backoff strategy. Do not expect the integration layer to absorb these faults magically.

## Generating the Now Book It MCP Server

Truto derives MCP tools dynamically. Instead of hand-coding tool definitions for Now Book It, Truto generates them on the fly based on the integration's documented API resources and schemas. You can generate a server URL via the UI or the REST API.

### Method 1: Via the Truto UI

For teams who prefer a visual setup, generating an MCP server takes just a few clicks:

1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select your connected Now Book It account.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (name, method filters like "read-only", specific tags, and expiration dates).
5. Click Save and copy the generated MCP server URL. It will look like `https://api.truto.one/mcp/abc123def456...`

### Method 2: Via the Truto API

For developers building programmatic onboarding flows, you can generate MCP servers via a simple POST request. This provisions a secure token and returns the ready-to-use URL.

```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": "Now Book It FoH Assistant",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["bookings", "schedules", "tables"]
    }
  }'
```

This generates an isolated server scoped specifically to that tenant's Now Book It instance.

## Connecting the MCP Server to Claude

Once you have your Truto MCP server URL, you must connect it to your Claude environment. The server utilizes a Server-Sent Events (SSE) transport layer to handle JSON-RPC messages.

### Method 1: Via the Claude UI

If you are using the consumer versions of Claude or ChatGPT that support remote MCP connections, you can add it directly through the settings interface:

1. Open your AI client (e.g., Claude Desktop or Web).
2. Navigate to **Settings** -> **Integrations** -> **Add MCP Server**.
3. Name the connector (e.g., "Now Book It Production").
4. Paste the Truto MCP URL.
5. Click **Add**. Claude will immediately handshake with the server and list the available restaurant tools.

### Method 2: Via Manual Configuration File

For developers running custom agents or using Claude Desktop with local configuration, you can mount the server by editing your `claude_desktop_config.json` file. Truto provides an NPM package (`@modelcontextprotocol/server-sse`) that acts as a proxy to handle the SSE connection from local clients.

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

Restart Claude Desktop, and the model will instantly have access to Now Book It.

## Security and Access Control

Giving an AI unrestricted access to your reservation book is dangerous. Truto provides granular controls to lock down exactly what the agent can do.

*   **Method Filtering (`config.methods`)**: Restrict the MCP server to `["read"]` only. This allows Claude to look up schedules and customer profiles without the ability to create bookings, process sales, or redeem gift cards.
*   **Tag Filtering (`config.tags`)**: Scope the server by domain. Passing `["gift_cards"]` ensures Claude can only access gift card tools, isolating it entirely from the core booking engine.
*   **Expiration (`expires_at`)**: Set a strict Time-to-Live (TTL) for the server. If you spin up an agent to run an end-of-day reconciliation, the server URL automatically self-destructs when the job is done.
*   **Additional Authentication (`require_api_token_auth`)**: For high-security deployments, checking this flag forces the MCP client to pass a valid Truto API token in the Authorization header. This means possessing the URL is not enough - the caller must also be authenticated as an active system user.

## Hero Tools for Now Book It

When the MCP server is initialized, Truto dynamically maps Now Book It resources into discrete, callable tools. Here are the highest-leverage tools available for your agent.

### List Schedules

**Tool Name:** `list_all_now_book_it_bookings_schedules`

This tool allows Claude to query available time slots based on a specific date, duration, and party size. Because it returns complex arrays, Claude can parse the schedule blocks and present natural-language options to the user.

> "What times do we have open tonight for a walk-in party of 6? Just give me the 3 earliest options."

### Create a Booking

**Tool Name:** `create_a_now_book_it_booking`

Creates a new reservation directly in the system. The tool enforces required fields like `numOfPeople` and returns the generated `bookingId` and `locationId`.

> "Book a table for John Smith for 2 people tomorrow at 8:00 PM. Add a note that it is an anniversary dinner."

### Update Table Assignments

**Tool Name:** `now_book_it_bookings_update_tables`

Allows the model to reassign physical tables to a specific `booking_id`. Crucially, it accepts the `allowTableBookingConflict` flag, enabling agents to force an override if authorized.

> "Move booking reference 98452 to Table 14. If there is a minor overlap with the previous seating, force the conflict override."

### Customer Lookup

**Tool Name:** `list_all_now_book_it_customers`

Searches customer profiles across the venue. Useful for retrieving a guest's history, verifying identity, or finding their internal ID for subsequent API calls.

> "Pull up the profile for Sarah Connor. When was the last time her record was updated?"

### Async Booking Updates

**Tool Name:** `now_book_it_bookings_update_booking_async`

Submits an asynchronous update request for an existing booking (e.g., changing the time or adding notes). Agents must be prompted to handle the 202 response appropriately.

> "Push an async update to add 'Allergy: Shellfish' to booking ID 773. Acknowledge when the request is accepted."

### Redeem Gift Cards

**Tool Name:** `now_book_it_gift_cards_redeem`

Executes a financial transaction against a gift card balance. Requires the specific `cardNumber` and redemption `amount`. The response details the `amountRedeemed` and the updated `status`.

> "The guest is paying with gift card number GC-99482. Redeem $150 from the balance and let me know if the card is now depleted."

### Create a Sale (POS Sync)

**Tool Name:** `create_a_now_book_it_sale`

Attaches a structured POS receipt or sales payload to an existing booking. This bridges the gap between the dining room and the back office.

> "Take this JSON receipt from the bar POS and attach it as a sale to table 4's current booking record."

*For the complete inventory of available Now Book It tools, schemas, and required parameters, visit the [Now Book It Integration Page](https://truto.one/integrations/detail/nowbookit).* 

## Workflows in Action

Access to individual tools is useful, but the real power of MCP is chaining these operations together to automate complex operational workflows.

### Workflow 1: VIP Walk-In and Table Reassignment

In a busy restaurant, accommodating a last-minute VIP requires juggling the floor plan. Claude can orchestrate this seamlessly by chaining schedule lookups, booking modifications, and table updates.

> "A VIP party of 4 just walked in. Check if we have availability right now. If not, look at our existing reservations for the next hour, find a non-VIP party of 4 on a premium table, move them to a standard table, and book the VIPs onto the premium table."

**Execution Steps:**
1. Claude calls `list_all_now_book_it_bookings_schedules` to check immediate availability for a party of 4.
2. If no premium tables are open, Claude calls `list_all_now_book_it_bookings` filtering by the current time window.
3. Claude identifies a standard booking, calls `now_book_it_bookings_update_tables` to move them to an alternate location.
4. Finally, Claude calls `create_a_now_book_it_booking` to insert the VIP party onto the newly freed premium table.

```mermaid
sequenceDiagram
  participant Agent as Claude Agent
  participant Truto as Truto MCP Server
  participant NowBookIt as Now Book It API

  Agent->>Truto: call list_all_now_book_it_bookings_schedules (pax: 4)
  Truto->>NowBookIt: GET /schedules
  NowBookIt-->>Truto: Return empty (no immediate premium availability)
  Truto-->>Agent: No availability
  
  Agent->>Truto: call list_all_now_book_it_bookings
  Truto->>NowBookIt: GET /bookings
  NowBookIt-->>Truto: Return bookings list
  Truto-->>Agent: Identify standard booking on premium table
  
  Agent->>Truto: call now_book_it_bookings_update_tables
  Truto->>NowBookIt: PUT /bookings/{id}/tables
  NowBookIt-->>Truto: 200 OK
  Truto-->>Agent: Success
  
  Agent->>Truto: call create_a_now_book_it_booking (VIP)
  Truto->>NowBookIt: POST /bookings
  NowBookIt-->>Truto: 201 Created (Booking ID)
  Truto-->>Agent: VIP booked successfully
```

### Workflow 2: End-of-Night Gift Card Reconciliation

Restaurant managers spend hours manually matching POS receipts to gift card redemptions. Claude can automate the data entry entirely.

> "I have a list of three gift card numbers and their intended redemption amounts from tonight's service. Redeem them in Now Book It. If any card has insufficient funds, stop and alert me. Otherwise, create a sales record for each successful redemption."

**Execution Steps:**
1. Claude loops through the provided cards, calling `get_single_now_book_it_gift_card_by_id` to verify balances.
2. For each valid card, Claude calls `now_book_it_gift_cards_redeem` to process the deduction.
3. Upon successful redemption, Claude calls `create_a_now_book_it_sale` to log the transaction against the respective booking or walk-in account.
4. Claude returns a summarized text report of all processed transactions.

```mermaid
flowchart TD
  A["Input: Gift Cards & Amounts"] --> B["Claude Agent"]
  B --> C{"Verify Balance <br> (get_single_gift_card)"}
  C -->|"Insufficient"| D["Halt & Alert User"]
  C -->|"Sufficient"| E["Process Redemption <br> (redeem_gift_card)"]
  E --> F["Create Sale Record <br> (create_a_sale)"]
  F --> G["Next Card / Generate Report"]
```

## Moving Beyond Manual Operations

Integrating Now Book It with Claude via MCP fundamentally changes how you build software for the hospitality sector. Instead of writing rigid, point-to-point scripts to handle floor plans or sync sales data, you provide an LLM with a curated set of deterministic tools and let it handle the orchestration.

By leveraging Truto's dynamic MCP generation, you avoid the technical debt of building custom JSON-RPC servers, managing complex OAuth lifecycles, and constantly updating schema definitions when the upstream API changes. 

> Stop hand-coding REST wrappers. Let Truto generate secure, production-ready MCP servers for your Now Book It integrations today.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)