Connect Now Book It to AI Agents: Automate Reservations & Webhooks

You want to connect Now Book It to an AI agent so your internal systems can independently read schedules, book tables, update party sizes, and configure webhooks based on real-time operational context. Here is exactly how to do it using Truto's /tools endpoint and SDK, bypassing the need to manually code dozens of endpoints or maintain complex API wrappers.

Giving a Large Language Model (LLM) read and write access to your venue management instance is an engineering headache. You either spend weeks building, hosting, and maintaining a custom connector that understands the granular differences between scheduling endpoints and table assignments, or you use a managed infrastructure layer that handles the boilerplate for you. If your team uses ChatGPT, check out our guide on connecting Now Book It to ChatGPT, and if you are building on Anthropic's models, read our guide on connecting Now Book It to Claude. For developers building custom autonomous workflows, you need a programmatic way to fetch these tools and bind them to your agent framework.

This guide breaks down exactly how to fetch AI-ready tools for Now Book It, bind them natively to an LLM using LangChain (or any framework like LangGraph, CrewAI, or Vercel AI SDK), and execute complex venue operations workflows. For a deeper look at the architecture behind this approach, refer to our research on architecting AI agents and the SaaS integration bottleneck.

The Engineering Reality of Custom Now Book It Connectors

Building AI agents is easy. Connecting them to external SaaS APIs is hard. Giving an LLM access to external venue data sounds simple in a prototype, often achieved via function calling. You write a Node.js function that makes a fetch request and wrap it in an @tool decorator. In production, this approach collapses entirely, especially with an ecosystem designed for high-concurrency physical venue management.

If you decide to integrate Now Book It yourself, you own the entire API lifecycle. Now Book It's API introduces several highly specific integration challenges that break standard LLM assumptions.

The Schedule and Alternative Timings Trap

Now Book It relies heavily on strict temporal logic for availability rather than simple list endpoints. When an agent needs to retrieve a list of available schedules, standard REST conventions fail. The agent must know how to formulate a valid query for list_all_now_book_it_bookings_schedules.

For example, if you want whole-day results, the agent must intentionally omit the BookingDateTimeEnd parameter. If a user wants to change an existing booking, the agent must pass the BookingId to fetch alternative timings specific to that exact booking's configuration. If you hand-code this integration, you have to write complex prompts to teach the LLM the exact syntax of these conditional parameters. When the LLM inevitably hallucinates and passes an end time while searching for a whole day, the API rejects the payload.

The Table Conflict and Party Size Disconnect

In venue management, updating a reservation is not a simple PUT request. There is a strict divide between the party size (pax) and the physical table assignment.

If an agent receives a request to update a booking from 2 people to 6, it cannot simply push { "numOfPeople": 6 }. It must use now_book_it_bookings_update_pax. However, changing the pax might invalidate the previously assigned table. To update tables, the agent must call a completely separate tool, now_book_it_bookings_update_tables, and correctly manage the allowTableBookingConflict boolean flag. Teaching an LLM to navigate this two-step validation process using raw API docs leads to endless edge-case failures.

Strict Rate Limiting Execution

Agents loop fast. When an autonomous workflow starts scanning schedules across multiple dates to find a specific open slot, it will rapidly hit the upstream Now Book It rate limits.

When a 429 Too Many Requests response occurs, Truto does not retry, throttle, or apply backoff on rate limit errors automatically. Instead, Truto passes that HTTP 429 error directly back to the caller. However, it normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. This means your agent must be built to read these standardized headers and implement its own retry and backoff logic. Handling this gracefully prevents the LLM from entering a panic loop where it continuously tries and fails to execute the same tool.

Why a Unified Tool Layer Matters for Agent Safety

Before writing a line of integration code, decide what layer your agent talks to. Direct API tools push provider quirks into the LLM's context. The model has to remember that Now Book It needs specific duration defaults (90 minutes) or that whole-day searches require omitting parameters. Every one of those quirks is a hallucination waiting to happen.

A unified tool layer collapses complex resources into predictable schemas. Your agent sees list_all_now_book_it_bookings_schedules and now_book_it_bookings_update_pax - backed by strict JSON schemas that reject bad data before it hits the network.

1. Smaller attack surface for hallucination. The LLM only ever chooses from stable function names. It never invents query parameters.
2. Deterministic input validation. Every tool has a strict JSON schema. Invalid arguments fail fast locally.
3. Decoupled authentication. The LLM never sees bearer tokens or OAuth credentials. Truto handles the proxying.
4. Standardized error handling. When that 429 hits, your agent framework reads a predictable ratelimit-reset header rather than parsing a vendor-specific text payload.

Fetching Now Book It Tools via the Truto API

Every integration on Truto is essentially a comprehensive JSON object that represents how an underlying product's API behaves. Resources map to the endpoints on the underlying product's API. Methods defined on these Resources are provided as Proxy APIs, where Truto handles pagination, authentication, and query parameter processing.

Truto provides a set of tools for your LLM frameworks by offering a description and schema for all the Methods defined on the Resources. We call the /integrated-account/:id/tools endpoint on the Truto API to return these Proxy APIs with their descriptions and schemas, creating Tools that LLM frameworks can consume directly.

Here is how you fetch the tools and pass them to an LLM using the Truto LangChain SDK.

import { ChatOpenAI } from "@langchain/openai";
import { TrutoToolManager } from "truto-langchainjs-toolset";
 
// 1. Initialize the LLM
const llm = new ChatOpenAI({
  modelName: "gpt-4o",
  temperature: 0,
});
 
// 2. Initialize the Truto Tool Manager with your Integrated Account ID
const toolManager = new TrutoToolManager({
  trutoApiKey: process.env.TRUTO_API_KEY,
  integratedAccountId: "your_now_book_it_account_id"
});
 
// 3. Fetch all available Now Book It tools dynamically
const tools = await toolManager.getTools();
 
// 4. Bind the tools to the LLM
const llmWithTools = llm.bindTools(tools);
 
// Now the LLM is fully equipped to execute Now Book It operations.

Hero Tools for Now Book It Automation

To build highly capable agents, you do not need to expose the entire API surface area. We recommend starting with a core set of high-leverage tools. Here are six crucial tools available via the Truto integration.

List Schedule Time Slots

list_all_now_book_it_bookings_schedules This tool queries available booking schedule time slots. It accepts date ranges and party sizes. For whole-day availability, the agent must omit the end time. Pass a BookingId to find alternative timings for an existing reservation.

"Find all available tables for a party of 4 on Friday evening starting at 7:00 PM."

Create a Booking

create_a_now_book_it_booking Used to generate a net-new booking in the system. It requires the number of people and returns critical identifiers like the bookingId, time, and duration.

"Book the 7:30 PM slot for John Doe's party of 4."

Update Party Size (Pax)

now_book_it_bookings_update_pax Specifically handles updating the party size for a given reservation without altering the rest of the payload.

"John Doe just called. Update his booking tonight from 4 people to 6 people."

Manage Table Assignments

now_book_it_bookings_update_tables Assigns or re-assigns physical tables to an existing booking_id. It requires an array of tables and explicitly demands the allowTableBookingConflict flag to govern overlap logic.

"Move booking ID 98765 to table 12, and override any minor conflicts."

Redeem Gift Cards

now_book_it_gift_cards_redeem Allows the agent to process gift card transactions directly against a customer's bill. It requires the cardNumber and the amount to redeem, returning the amountRedeemed and success status.

"Apply fifty dollars from gift card number 11223344 against the current bill."

Configure Event Webhooks

create_a_now_book_it_webhook Essential for building reactive agent systems. This tool allows the agent to subscribe your backend to specific event types in the venue's system, returning the active webhookUrl and eventType.

"Set up a webhook to notify my endpoint whenever a new booking is created."

To see the full schema definitions and the complete inventory of available operations, visit the Now Book It integration page.

Workflows in Action

Providing tools to an agent is only half the battle. The real value unlocks when the agent orchestrates multi-step workflows across these endpoints autonomously. Here are two concrete examples of how an agent uses the tools provided above.

Scenario 1: The Autonomous Reservation Concierge

Persona: Venue Operations / Front of House

"A customer wants to move their 8 PM booking for 4 people tonight to tomorrow at the same time. Check if we have space and update it."

Agent Execution Steps:

1. The agent calls list_all_now_book_it_bookings filtering by today's date and the customer's name to retrieve the original bookingId.
2. The agent calls list_all_now_book_it_bookings_schedules passing tomorrow's date, num_of_people: 4, and the BookingId from step 1. This ensures it queries alternative timings specific to that booking type.
3. Seeing an available slot for 8 PM tomorrow, the agent calls now_book_it_bookings_update_booking_async with the new date and time parameters.

Result: The customer is moved to the new date seamlessly, and the agent confirms the new details based on the exact API response.

Scenario 2: Marketing & VIP Management

Persona: Venue Manager

"Look up VIP customer Sarah Jenkins. See if she has any active gift cards, and if so, make sure we are subscribed to webhooks for when she redeems them."

Agent Execution Steps:

1. The agent calls list_all_now_book_it_customers filtering for "Sarah Jenkins" to extract her unique customer ID.
2. The agent executes list_all_now_book_it_gift_cards cross-referencing her details to find active balances.
3. The agent calls list_all_now_book_it_webhooks to check current subscriptions.
4. Realizing there is no hook for gift card events, the agent calls create_a_now_book_it_webhook passing the gift card redemption event type and the venue's callback URL.

Result: The manager receives confirmation of Sarah's gift card balance, and the system is now wired to alert the backend the moment she uses it on-site.

Building Multi-Step Workflows

To execute the workflows above, you need an agent loop that respects the architectural constraints of the upstream API. Most notably, you must handle the reality of rate limits.

Truto passes HTTP 429s directly to your application while normalizing the headers to ratelimit-limit, ratelimit-remaining, and ratelimit-reset. Your agent execution loop must catch these errors, inspect the reset header, wait, and retry the tool execution.

Here is how you structure a robust agent loop using LangGraph that handles tool execution and backoff logic elegantly.

sequenceDiagram
    participant App as Your App
    participant Agent as AI Agent (LangGraph)
    participant Truto as Truto Tool Manager
    participant NBI as Now Book It API

    App->>Agent: "Find tables for 4 tonight"
    Agent->>Truto: call: list_all_now_book_it_bookings_schedules
    Truto->>NBI: GET /schedules
    NBI-->>Truto: HTTP 429 Too Many Requests
    Truto-->>Agent: HTTP 429 (ratelimit-reset: 5)
    note over Agent: Agent parses header<br>Executes sleep(5000)
    Agent->>Truto: retry: list_all_now_book_it_bookings_schedules
    Truto->>NBI: GET /schedules
    NBI-->>Truto: 200 OK (Schedule Data)
    Truto-->>Agent: Normalized JSON
    Agent-->>App: "Tables available at 6 PM, 7 PM..."

The Agent Execution Code

This framework-agnostic approach demonstrates how to trap the 429 error inside a tool execution wrapper, forcing the agent to pause before continuing its autonomous thought process.

import { ChatOpenAI } from "@langchain/openai";
import { TrutoToolManager } from "truto-langchainjs-toolset";
import { HumanMessage } from "@langchain/core/messages";
 
async function runNowBookItAgent(prompt: string) {
  const llm = new ChatOpenAI({ modelName: "gpt-4o", temperature: 0 });
  
  const toolManager = new TrutoToolManager({
    trutoApiKey: process.env.TRUTO_API_KEY,
    integratedAccountId: "your_now_book_it_account_id"
  });
 
  // Fetch schemas from Truto
  const tools = await toolManager.getTools();
  const llmWithTools = llm.bindTools(tools);
 
  const messages = [new HumanMessage(prompt)];
 
  // Basic Agent Loop
  while (true) {
    const response = await llmWithTools.invoke(messages);
    messages.push(response);
 
    // If the LLM didn't call a tool, we are done.
    if (!response.tool_calls || response.tool_calls.length === 0) {
      console.log("Agent Final Answer:", response.content);
      break;
    }
 
    // Execute requested tools
    for (const toolCall of response.tool_calls) {
      const selectedTool = tools.find(t => t.name === toolCall.name);
      if (selectedTool) {
        try {
          const toolResult = await selectedTool.invoke(toolCall.args);
          messages.push({
            role: "tool",
            tool_call_id: toolCall.id,
            name: toolCall.name,
            content: JSON.stringify(toolResult)
          });
        } catch (error: any) {
          // Handle the direct 429 pass-through from Truto
          if (error.response && error.response.status === 429) {
            const resetInSeconds = parseInt(error.response.headers.get('ratelimit-reset') || '5', 10);
            console.warn(`Rate limit hit. Agent backing off for ${resetInSeconds} seconds...`);
            
            // Sleep to respect the IETF spec header
            await new Promise(resolve => setTimeout(resolve, resetInSeconds * 1000));
            
            // Inform the LLM to try again on the next iteration
            messages.push({
              role: "tool",
              tool_call_id: toolCall.id,
              name: toolCall.name,
              content: "Error: 429 Too Many Requests. The system paused. Please retry the tool call now."
            });
          } else {
            // Pass standard errors back to the LLM for correction
            messages.push({
              role: "tool",
              tool_call_id: toolCall.id,
              name: toolCall.name,
              content: `Error executing tool: ${error.message}`
            });
          }
        }
      }
    }
  }
}
 
// Execute
runNowBookItAgent("Check the schedules for a party of 4 this Friday.");

By ensuring the agent loop handles the 429 gracefully, you prevent the LLM from burning through tokens repeatedly slamming a locked API. The agent receives the error, waits exactly as long as the ratelimit-reset header dictates, and organically decides to retry the action.

Final Thoughts

Giving an AI agent access to physical venue management software requires strict architectural boundaries. If you expose raw, un-normalized endpoints, the LLM will hallucinate query parameters, fail to understand schedule logic, and crash against rate limits.

By leveraging Truto's /tools endpoint, you collapse the complex Now Book It API into deterministic, schema-validated functions. Your agent focuses entirely on reasoning and workflow orchestration, while Truto handles the underlying authentication, pagination, and data proxying.