Connect Toast to Claude: Sync Menu, Labor, and Kitchen Workflows

If your team uses ChatGPT, check out our guide on connecting Toast to ChatGPT or explore our broader architectural overview on connecting Toast to AI Agents.

If you need to connect Toast to Claude to automate restaurant operations, manage menu inventory, or reconcile complex labor reports, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Toast's REST APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

Giving a Large Language Model (LLM) read and write access to a mission-critical Point of Sale (POS) and restaurant management system like Toast is a serious engineering challenge. You have to handle fragmented data schemas, navigate asynchronous reporting endpoints, and map massive restaurant hierarchies to MCP tool definitions. Every time Toast updates a Configuration API endpoint or deprecates a reporting schema, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Toast, connect it natively to Claude, and execute complex kitchen and front-of-house workflows using natural language.

The Engineering Reality of the Toast 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 POS APIs is painful. Toast is built to manage complex restaurant groups, highly configurable menus, and deeply nested order structures. Its API reflects that complexity.

If you decide to build a custom Toast MCP server, here are the specific integration challenges you will face:

The Asynchronous 202 Accepted Polling Trap Toast does not calculate massive reporting datasets (like labor, metrics, and payouts) on the fly. Endpoints like the Toast Analytics API operate on an asynchronous pattern. First, you must issue a POST request (e.g., create_a_toast_labor) with a date range to generate a reportRequestGuid. Then, you must repeatedly poll the list endpoint (e.g., list_all_toast_labors) with that GUID. While Toast is calculating the data, the API returns a 202 Accepted status. Only when the report is ready does it return a 200 OK with the payload. LLMs struggle with asynchronous polling loops unless the MCP tool schemas explicitly instruct them on how to handle the 202 response and when to retry.

Nested Menu Hierarchies and GUIDs The Toast Configuration API relies heavily on platform-specific GUIDs. If an LLM wants to mark a specific modifier as out of stock, it cannot just pass the string "Extra Bacon". It must know the exact multiLocationId or guid of the menu item, which often requires traversing from a MenuGroup to a MenuItem to a MenuOptionGroup. A managed MCP server exposes tools that allow the LLM to query these entities sequentially, mapping human-readable names to the necessary platform GUIDs required for write operations.

Strict Order Calculation Dependencies Creating an order in Toast is not a single API call. Before an order can be persisted, you must calculate the taxes, service charges, and prices based on the specific dining option and business date. This requires hitting the pricing endpoints before executing the final order creation. An LLM requires strictly defined schemas to understand this operational order dependency.

How to Create the Toast MCP Server

Truto automatically generates MCP tools dynamically based on the Toast integration's API documentation and endpoint schemas. You can generate a secure MCP server URL via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

If you are setting up an internal tool for your operations team, the easiest way to generate an MCP server is through the dashboard.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Toast account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server parameters. You can filter the server to only expose read methods (to prevent accidental menu changes) or restrict tools using tags (like inventory or reporting).
5. Click Save and copy the generated https://api.truto.one/mcp/... URL. This URL contains a securely hashed cryptographic token.

Method 2: Via the Truto API

If you are dynamically provisioning MCP servers for your end-users, you should use the REST API. This creates a secure, tenant-scoped MCP server on the fly.

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Toast Kitchen Ops Server",
    "config": {
      "methods": ["read", "write"],
      "tags": ["inventory", "menu", "orders"]
    }
  }'

The API will return a JSON payload containing the ready-to-use MCP URL:

{
  "id": "mcp-toast-789",
  "name": "Toast Kitchen Ops Server",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the Toast MCP Server to Claude

Once you have your MCP URL, you can connect it to Claude. You can do this directly in the Claude UI for individual users, or configure it via the Claude Desktop config file for automated local environments.

Method 1: Via the Claude UI

1. Open the Claude app and navigate to Settings.
2. Select Integrations (or Connectors) and click Add MCP Server.
3. Give the server a descriptive name (e.g., "Toast Integration").
4. Paste the Truto MCP URL into the connection field.
5. Click Add. Claude will immediately execute the initialize and tools/list JSON-RPC handshake, pulling in all available Toast tools.

Method 2: Via the Claude Desktop Config File

If you are managing local developer environments, you can inject the MCP server directly into Claude Desktop's configuration JSON.

Open your claude_desktop_config.json file (typically located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS) and add the Server-Sent Events (SSE) configuration:

{
  "mcpServers": {
    "toast-ops": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/a1b2c3d4e5f6..."
      ]
    }
  }
}

Restart Claude Desktop. The application will read the configuration, connect to the Truto SSE transport, and register the Toast tools.

Hero Tools for Toast Automation

Truto exposes the entirety of the Toast REST API as discrete MCP tools. Here are the highest-leverage tools for automating restaurant operations.

1. list_all_toast_menus

This tool retrieves all menus configured for a specific Toast restaurant, including drinks, dinner, and dessert menus. It is the necessary first step for an LLM to navigate the POS hierarchy and find the specific GUIDs required for subsequent inventory or pricing updates.

"Claude, pull the current dinner menu from Toast. I need to see the exact structure and internal identifiers for the steaks category so we can update the inventory status."

2. toast_inventory_updates_bulk_update

Kitchen staff need to quickly 86 (mark out of stock) items during a busy rush. This tool allows the LLM to update inventory information for a list of menu items by passing an array of MenuItemInventory objects with statuses like IN_STOCK, OUT_OF_STOCK, or QUANTITY.

"Claude, the kitchen just ran out of ribeye. Use the bulk inventory update tool to set the status of the Ribeye Steak item to OUT_OF_STOCK across all locations."

3. create_a_toast_labor

This tool kicks off the asynchronous labor reporting process. The LLM passes a specific time range (e.g., startBusinessDate and endBusinessDate), and Toast returns a reportRequestGuid used to track the compilation of the data.

"Claude, initiate a labor report request for yesterday's business date. Give me the report request GUID so we can check on it in a moment."

4. list_all_toast_labors

Used in conjunction with the creation tool, this tool fetches the actual labor reporting data using the report_request_guid. The tool schema explicitly tells the LLM to expect a 202 response while the platform gathers the data, allowing the model to enter a retry loop until the payload is ready.

"Claude, use the GUID we just generated to fetch the labor report. If the API returns a 202 Accepted, wait 10 seconds and try again until the data is available. Once you have it, summarize the total overtime hours."

5. create_a_toast_order

This tool creates a new guest order directly in the POS. It requires a highly structured Order object describing the checks, item selections, and dining options. Because credit card payment types are not supported via this specific endpoint, it is typically used for third-party ordering integrations or house accounts.

"Claude, create a new takeout order in Toast for John Doe. Add two Cheeseburgers and one large fry to the check, and set the dining option to TAKE_OUT."

6. list_all_toast_published_prep_stations

This tool lists all prep stations (kitchen printers or Kitchen Display System devices) configured for a restaurant. It is critical for routing custom notes or understanding where specific items are fulfilled.

"Claude, list all the published prep stations in Toast. I need to find the GUID for the Grill Station KDS so we can verify its routing rules."

For the complete inventory of available tools, including detailed JSON schema definitions for query parameters and request bodies, view the Toast integration page.

Workflows in Action

An MCP server turns static API endpoints into dynamic, multi-step workflows. By giving Claude access to Toast, you can automate complex operational reconciliations that would normally require a restaurant manager to manually export CSVs from the Toast backend.

Scenario 1: The Automated Kitchen 86 Workflow

When a kitchen runs out of a core ingredient, a manager must quickly update the POS to prevent front-of-house staff from ringing it in. An AI agent can handle this entire flow.

"Claude, the kitchen is completely out of avocados. Find all menu items that contain avocado, mark them as OUT_OF_STOCK, and then verify the prep stations associated with those items."

1. Claude calls list_all_toast_menus to retrieve the menu hierarchy.
2. Claude parses the returned JSON to locate the multiLocationId or guid for the "Avocado Add-on" and "Guacamole" items.
3. Claude calls toast_inventory_updates_bulk_update passing the extracted GUIDs and setting the status to OUT_OF_STOCK.
4. Claude calls list_all_toast_published_prep_stations to confirm which KDS screens handle those items, ensuring the kitchen is aligned with the POS state.

sequenceDiagram
  participant User as Restaurant Manager
  participant Claude as Claude
  participant Toast as Toast MCP Server
  
  User->>Claude: "We are out of avocados. 86 them."
  Claude->>Toast: Call list_all_toast_menus
  Toast-->>Claude: Returns menu JSON with GUIDs
  Claude->>Toast: Call toast_inventory_updates_bulk_update(OUT_OF_STOCK)
  Toast-->>Claude: 200 OK (Inventory Updated)
  Claude->>Toast: Call list_all_toast_published_prep_stations
  Toast-->>Claude: Returns KDS routing data
  Claude-->>User: "Avocados are marked out of stock. Prep stations notified."

Scenario 2: End-of-Day Labor Reconciliation

Reconciling labor costs against sales metrics requires handling Toast's asynchronous reporting endpoints. The LLM must navigate the 202 Accepted polling mechanism.

"Claude, generate a labor report and a sales metrics report for yesterday. Wait for both reports to finish generating, then calculate our labor-as-a-percentage-of-sales ratio."

1. Claude calls create_a_toast_labor with yesterday's businessDate.
2. Toast returns a reportRequestGuid.
3. Claude calls list_all_toast_labors using the GUID. It receives a 202 status, indicating the report is processing. Claude waits, then retries the tool until it receives the 200 OK payload containing labor costs.
4. Claude calls create_a_toast_metric to request aggregated sales data.
5. Toast returns a second reportRequestGuid.
6. Claude loops list_all_toast_metrics until the sales data is returned.
7. Claude performs the mathematical calculation and presents the labor percentage to the user.

Security and Access Control

Giving an AI agent access to a live POS system requires strict security boundaries. Truto MCP servers enforce access control at the infrastructure level.

• Method Filtering: You can restrict a Toast MCP server to specific HTTP methods. Passing methods: ["read"] ensures the LLM can pull menus and read labor reports, but physically cannot call create_a_toast_order or modify inventory.
• Tag Filtering: You can scope the server by functional tags. Configuring the server with tags: ["inventory"] ensures the agent only sees tools related to stock levels, hiding sensitive employee or payout tools.
• Time-to-Live (TTL): By setting the expires_at parameter during server creation, you can generate temporary access credentials. Once the timestamp passes, the server URL is automatically invalidated.
• Secondary Authentication: Setting require_api_token_auth: true forces the MCP client to pass a valid Truto API token in the headers. This ensures that even if the MCP URL is leaked, unauthorized users cannot execute tools.

Handling Rate Limits

Toast applies strict rate limits to prevent API abuse, particularly on reporting endpoints. Truto does not retry, throttle, or apply backoff on rate limit errors.

When the Toast API returns an HTTP 429 (Too Many Requests), Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit information into standardized HTTP headers per the IETF specification:

• ratelimit-limit: The total requests allowed in the current window.
• ratelimit-remaining: The number of requests left.
• ratelimit-reset: The time at which the window resets.

Your AI agent, or the framework orchestrating it, is entirely responsible for reading these headers and implementing its own retry logic or exponential backoff.

The Strategic Value of Managed MCP

Connecting Claude to Toast requires more than just mapping API endpoints. You have to handle authentication, parse nested REST payloads into flat MCP tool arguments, and manage the execution of asynchronous reporting jobs.

By utilizing Truto's dynamic MCP generation, you outsource the entire integration lifecycle. When Toast deprecates a V1 endpoint or introduces a new inventory schema, Truto updates the definitions globally. Your AI agents instantly discover the updated tools without requiring a single line of code changes on your end.

Stop building point-to-point POS integrations. Focus on building intelligent restaurant workflows, and let the infrastructure handle the API translation.