Connect Toast to ChatGPT: Analyze Sales and Manage Restaurant Ops

If you need to connect Toast to ChatGPT to analyze daily sales, manage labor reporting, or update restaurant menus, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool-calling capabilities and Toast's complex, asynchronously-driven REST API. You can either spend weeks building and hosting 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 Toast to Claude or explore our broader architectural overview on connecting Toast to AI Agents.

Giving a Large Language Model (LLM) read and write access to a point-of-sale platform handling sensitive financial data is a massive engineering challenge. You must navigate asynchronous report generation, multi-location identifier mapping, and strict rate limits. Every time Toast updates a schema or adds a new reporting dimension, custom server code must be updated, redeployed, and tested.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Toast, connect it natively to ChatGPT, and execute complex restaurant operations using natural language.

The Engineering Reality of the Toast API

A custom MCP server is essentially a self-hosted integration proxy. While the open MCP standard provides a predictable way for models to discover tools, implementing it against Toast's highly specific POS and analytics architecture is exceptionally painful.

If you decide to build a custom MCP server for Toast, you own the entire API lifecycle. Here are the specific integration challenges that break standard REST CRUD assumptions when working with Toast:

The Asynchronous Reporting Pattern

Unlike typical SaaS APIs where a GET /sales returns your data immediately, Toast relies heavily on asynchronous data generation for its analytics (checks, labor, payouts). When an LLM wants to analyze check data, it cannot just call a list endpoint. It must first call a create endpoint to define the report parameters, which returns a reportRequestGuid. The LLM must then take that GUID and poll a list endpoint.

While the platform is still gathering the data, the API returns an HTTP 202 status. Your MCP server must pass this 202 back to the LLM explicitly, providing instructions in the tool description that the LLM must wait and try again. Building an MCP tool definition that successfully teaches an LLM to navigate a 202-polling loop is a complex prompt engineering and schema-mapping task.

Multi-Location Identifier Dependency

Toast operates on a strict hierarchy of Management Groups and individual Restaurant GUIDs. Almost every functional API call requires passing specific location identifiers either in the body, the path, or via headers (like the Toast-Restaurant-External-ID). When connecting ChatGPT to Toast, your MCP server must handle the context of which restaurant the user is asking about. If a franchise operator asks ChatGPT to "update the lunch menu," the LLM must be equipped with tools to first query the available restaurant GUIDs, find the target location, and inject that context into the subsequent menu update request.

Rate Limits and Backoff Responsibility

Toast enforces rate limits to ensure POS stability. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Toast API returns an HTTP 429 (Too Many Requests), Truto passes that error directly to the caller.

Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. Your AI agent framework—or ChatGPT's native retry logic—must inspect these headers and implement its own backoff strategy. Do not build custom MCP proxies expecting the middle layer to absorb 429s; the caller is ultimately responsible for retry pacing.

Creating the Toast MCP Server

Truto allows you to generate a fully authenticated MCP server for a specific Toast account. You can accomplish this either via the Truto UI for rapid prototyping, or programmatically via the API for scalable deployments.

Method 1: Via the Truto UI

The fastest way to connect ChatGPT to a specific Toast instance is through the Truto dashboard.

1. Navigate to the Integrated Accounts page for your connected Toast instance.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (name, allowed HTTP methods, tags, and expiration).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the Truto API

For production workflows where you need to spin up AI agents dynamically for your end-users, you can provision MCP servers over the API.

Issue a POST request to /integrated-account/:id/mcp with your desired configuration:

curl -X POST https://api.truto.one/integrated-account/<INTEGRATED_ACCOUNT_ID>/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ChatGPT Toast Assistant",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["reporting", "orders", "menus"]
    }
  }'

The response contains the secure URL you will use to connect the client:

{
  "id": "abc-123",
  "name": "ChatGPT Toast Assistant",
  "config": {
    "methods": ["read", "write", "custom"],
    "tags": ["reporting", "orders", "menus"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can plug it into your AI client. Depending on how you utilize ChatGPT, there are two primary methods for connection.

Method A: Via the ChatGPT UI (Custom Connectors)

If you are using the ChatGPT web interface on a Pro, Plus, Business, Enterprise, or Education plan, you can connect the server natively:

1. In ChatGPT, navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name: Enter a recognizable name (e.g., "Toast POS").
5. Server URL: Paste the Truto MCP URL you generated earlier.
6. Save the configuration. ChatGPT will instantly perform the initialization handshake and list all available Toast tools.

(Note: If you are connecting Claude Desktop instead, navigate to Settings → Integrations → Add MCP Server, paste the URL, and click Add.)

Method B: Via Manual Config File (SSE Transport)

If you are running your own AI agent framework (like LangChain, AutoGen, or a custom ChatGPT wrapper) and need to connect programmatically, you can configure the MCP connection using the Server-Sent Events (SSE) transport adapter.

Because Truto exposes the MCP server over HTTP SSE, you must route it through the official @modelcontextprotocol/server-sse proxy if your local client expects standard stdio. Update your MCP configuration file (e.g., mcp_config.json):

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

When your agent boots up, it will execute the npx command, bridging the SSE stream into stdio, allowing seamless tool discovery and execution.

Hero Tools for Toast Operations

Truto automatically generates MCP tools from the integration's documentation and resource schemas. When you connect your Toast MCP server, ChatGPT gains access to these specific operations. Here are the highest-leverage hero tools for automating restaurant workflows.

create_a_toast_check

This tool initiates the asynchronous process of gathering check reporting data for a specific time range. Because Toast must aggregate massive amounts of POS data, this tool does not return the data immediately; it returns a reportRequestGuid.

Contextual Usage: Use this tool as step one in any sales, discounting, or receipt analysis workflow. The LLM must capture the GUID to use in the subsequent list tool.

"I need to run an analysis on our check data for yesterday. Please create a check reporting request for the date 20231025 and give me the request ID."

list_all_toast_checks

Retrieves the check reporting data for a previously requested reportRequestGuid.

Contextual Usage: The LLM uses this tool to poll for results. The schema explicitly instructs the model that if it receives a 202 Accepted, it should wait briefly and execute the tool again until the full data payload is returned.

"Using the report request ID you just generated, retrieve the check reporting data. If it says it's still processing, wait a few seconds and try again until you have the final JSON data."

list_all_toast_payouts

Retrieves the Toast payout reporting data organized by settled date. This is critical for financial reconciliation, mapping what the restaurant actually received in their bank account against recorded sales.

Contextual Usage: Like checks, payouts are asynchronous. This tool is the read-stage of the payout workflow, returning transaction counts, payment amounts, and withheld fees.

"Pull the payout report for the request ID we just created. I need to know the total refund amount and withholding amount for the downtown location yesterday."

list_all_toast_shifts

Lists schedule shifts for restaurant employees. This tool returns Shift objects including in-times, out-times, job references, and employee identifiers.

Contextual Usage: Essential for labor cost calculations. The LLM can use this to compare scheduled labor hours against actual sales volume pulled from the check reporting tools.

"List all the shifts that occurred yesterday. Calculate the total number of hours worked by employees assigned to the 'Bartender' job reference."

create_a_toast_order

Creates a new guest order directly in the Toast POS. Returns the persisted Order object including a generated GUID, dining option, and nested checks with item selections.

Contextual Usage: Used for programmatic order injection (e.g., a custom AI drive-thru assistant or catering intake bot). Note that credit card payment types are not supported directly through this endpoint.

"Create a new order in Toast for a 'Takeout' dining option. Add one check to the order containing two 'Cheeseburger' selections, referencing their item GUIDs."

list_all_toast_menus

Lists all menus configured for a specific Toast restaurant, such as drinks, dinner, and dessert menus.

Contextual Usage: Used by the LLM to understand the hierarchy of the restaurant's offerings before attempting to drill down into specific items or modifying inventory statuses.

"List all the menus configured for this restaurant. Tell me the unique GUID for the 'Late Night' menu so we can audit its items."

list_all_toast_inventories

Lists the menu item inventory for a restaurant. Only returns items that are currently marked as OUT_OF_STOCK or have a specific QUANTITY limit.

Contextual Usage: Highly actionable tool for kitchen ops. The AI can check 86'd items or low-stock items at the start of a shift.

"Check the current inventory levels and list every item that is currently marked as OUT_OF_STOCK. Group them by their multi-location IDs."

For a complete list of available Toast tools, including payroll adjustments, loyalty programs, and delivery configurations, view the complete tool inventory and schema definitions on the Toast integration page.

Workflows in Action

By chaining these tools together, ChatGPT can execute complex, multi-step operations that traditionally require a manager to log into the Toast Web portal.

1. End-of-Day Financial Reconciliation

A restaurant general manager needs to match their bank deposits with yesterday's POS data.

"Generate an end-of-day reconciliation for yesterday. First, create a payout reporting request for the date 20231026. Then retrieve the data. Compare the 'payoutAmount' against the total sales from the check reporting endpoint for the same day. Tell me if there are any discrepancies."

Step-by-step execution:

1. ChatGPT calls create_a_toast_payout with startDate and endDate set to yesterday.
2. ChatGPT extracts the reportRequestGuid.
3. ChatGPT calls list_all_toast_payouts using the GUID (handling any 202 responses by retrying).
4. ChatGPT calls create_a_toast_check for yesterday, gets the new GUID.
5. ChatGPT calls list_all_toast_checks to pull gross sales.
6. ChatGPT processes the JSON arrays and outputs a plain-english summary of the daily financials.

sequenceDiagram
    participant User as Store Manager
    participant LLM as ChatGPT
    participant Truto as MCP Server
    participant API as Toast API

    User->>LLM: "Reconcile yesterday's payouts..."
    LLM->>Truto: create_a_toast_payout
    Truto->>API: POST /reporting/payouts
    API-->>Truto: return reportRequestGuid
    Truto-->>LLM: guid: "pay-8899"
    LLM->>Truto: list_all_toast_payouts("pay-8899")
    Truto->>API: GET /reporting/payouts/pay-8899
    API-->>Truto: 200 OK (Payout Data)
    Truto-->>LLM: Array of Payout objects
    Note over LLM: LLM runs calculations
    LLM-->>User: "Reconciliation complete. Payouts match gross sales..."

2. Labor Cost vs. Volume Analysis

An operations director wants to identify overstaffing during slow hours.

"I need an efficiency report for yesterday. Pull all employee shifts for the day. Then, pull the check reporting data. Cross-reference the timeline of opened checks against the active shifts. Identify any two-hour windows where we had more than 5 staff members clocked in but generated less than $200 in sales."

Step-by-step execution:

1. ChatGPT calls list_all_toast_shifts with a start and end date.
2. ChatGPT initiates a check report via create_a_toast_check.
3. ChatGPT polls list_all_toast_checks until data is ready.
4. ChatGPT maps the timestamps of the checks (openedDate) against the inDate and outDate of the shift arrays.
5. ChatGPT calculates the revenue per hour versus labor cost and flags the inefficient windows.

3. Kitchen 86'd Item Audit

A Food & Beverage Director wants to audit the current state of out-of-stock items across the menu to coordinate with suppliers.

"Check the inventory to see what is currently out of stock. For each out of stock item, look up its details in the menu items list and give me a summary of the categories that are most impacted right now."

Step-by-step execution:

1. ChatGPT calls list_all_toast_inventories focusing on the OUT_OF_STOCK status.
2. ChatGPT extracts the guid for each missing item.
3. ChatGPT iterates over the items by calling get_single_toast_menu_item_by_id for each GUID.
4. ChatGPT groups the items by their parent SalesCategory or MenuGroup.
5. ChatGPT replies to the user with a formatted list highlighting which menu sections (e.g., "Draft Beer", "Appetizers") are severely depleted.

Security and Access Control

Giving an LLM access to your POS system introduces risk. Truto provides granular security controls at the MCP token level to ensure ChatGPT only executes permitted actions.

When provisioning an MCP server via POST /integrated-account/:id/mcp, you can enforce the following constraints inside the config object:

• Method Filtering (methods): Restrict the server to safe operations. Setting "methods": ["read"] ensures the LLM can only call get and list operations (e.g., reading reports). It mathematically prevents ChatGPT from accidentally voiding an order or deleting an employee.
• Tag Filtering (tags): Scope the API surface area by domain. Setting "tags": ["inventory", "menus"] hides all financial and payroll tools from the LLM, reducing the risk of hallucinated calls to sensitive endpoints.
• Token Authentication (require_api_token_auth): By default, the MCP URL is a bearer token itself. If you set this to true, the connecting client must also pass a valid Truto API token in the headers, adding a layer of identity verification.
• Expiration (expires_at): Provide an ISO datetime string to create temporary access. If you have an external AI auditor reviewing financials, you can issue an MCP URL that automatically self-destructs after 48 hours.

Moving Past Boilerplate Integration Code

Connecting a multi-modal agent to a sprawling API like Toast should not require weeks of writing schema mappers, pagination loops, and long-polling logic. The true value of AI in restaurant operations lies in orchestration and analysis, not in maintaining REST API wrappers.

By leveraging Truto to automatically derive MCP tools directly from the Toast documentation, you collapse the integration lifecycle. Your AI agents gain immediate, context-aware access to real-time sales, labor, and menu data, while your engineering team avoids the maintenance burden of undocumented upstream changes.