---
title: "Connect Wave to ChatGPT: Manage Invoices, Estimates & Accounts"
slug: connect-wave-to-chatgpt-manage-invoices-estimates-accounts
date: 2026-06-09
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to build a managed MCP server to connect Wave to ChatGPT. Automate invoices, estimates, and customer management with AI agents."
tldr: "Connecting Wave to ChatGPT requires translating LLM tool calls into complex API requests. This guide shows how to deploy a managed Truto MCP server to automate Wave invoicing, estimate conversions, and reconciliation without writing custom integration boilerplate."
canonical: https://truto.one/blog/connect-wave-to-chatgpt-manage-invoices-estimates-accounts/
---

# Connect Wave to ChatGPT: Manage Invoices, Estimates & Accounts


You want to connect Wave to ChatGPT so your AI agents can read financial data, draft invoices, manage estimates, and [reconcile transactions using natural language](https://truto.one/can-ai-agents-write-data-back-to-accounting-systems-like-quickbooks/). If your team uses Claude, check out our guide on [connecting Wave to Claude](https://truto.one/connect-wave-to-claude-sync-customers-products-and-sales-taxes/) or explore our broader architectural overview on [connecting Wave to AI Agents](https://truto.one/connect-wave-to-ai-agents-automate-transactions-billing-tasks/). Here is exactly how to do it using a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/).

Giving a Large Language Model (LLM) read and write access to a sprawling financial ecosystem like Wave is an engineering challenge. You either spend weeks building, hosting, and maintaining a custom MCP server to translate LLM tool calls into Wave's specific GraphQL mutations, or you use a [managed infrastructure layer](https://truto.one/the-best-unified-accounting-api-for-b2b-saas-and-ai-agents-2026/) that handles the boilerplate for you. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Wave, connect it natively to ChatGPT, and execute complex accounting workflows using natural language.

## The Engineering Reality of the Wave API

A custom MCP server is a self-hosted integration layer that translates an LLM's tool calls into API requests. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Wave's APIs is painful.

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

### The GraphQL to REST Impedance Mismatch
Wave's API is heavily built on GraphQL. AI models generally expect standard RESTful tool definitions with distinct query parameters and request bodies. Exposing a GraphQL endpoint to an LLM directly is a recipe for hallucinations, as the model struggles to consistently construct complex, deeply nested GraphQL query strings. Your MCP server must act as a translation layer, mapping discrete AI tool operations (like `create_a_wave_invoice`) into the highly specific `invoiceCreate` GraphQL mutation.

### Validation Failures via inputErrors []
When you submit a bad payload to a standard REST API, you expect an HTTP 400 response with an error message. Wave's API handles validation differently. A mutation might return an HTTP 200 OK, but the response body will contain an `inputErrors []` array detailing field-level validation failures (e.g., missing a required `businessId` or `customerId`). If your MCP server does not intercept and explicitly feed these `inputErrors` back to the LLM, the AI agent will assume the tool call succeeded and hallucinate a confirmation to the user.

### The isClassicAccounting Migration Flag
Wave is transitioning its transaction models. If an LLM attempts to use the `moneyTransactionCreate` tool, the operation will hard-fail unless the Wave business account has `isClassicAccounting` set to `false`. Your integration logic has to be aware of the account state and pass the correct context, or the AI agent will get stuck in an endless loop of failed transaction creation attempts.

### Strict Rate Limits and 429 Errors
Wave enforces strict rate limits to protect its infrastructure. If an AI agent attempts to bulk-sync hundreds of transactions in a tight loop, Wave will return an HTTP 429 Too Many Requests error. 

It is critical to understand that **Truto does not retry, throttle, or apply backoff on rate limit errors.** When the upstream Wave API returns an HTTP 429, Truto passes that exact error directly back to the caller. What Truto does do is normalize the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller (your AI agent framework or ChatGPT client) is entirely responsible for reading these headers and implementing its own retry and exponential backoff logic.

## The Managed MCP Approach

Instead of forcing your engineering team to build OAuth token managers, map GraphQL mutations to JSON schemas, and host infrastructure, Truto provides a managed MCP layer. 

When a customer connects their Wave account to your platform, Truto dynamically generates an MCP server specific to that tenant. Truto derives the available tools directly from the Wave integration resources and documentation. 

Here is how to generate a secure MCP server URL for Wave and connect it to ChatGPT.

### Step 1: Create the Wave MCP Server

You can generate an MCP server for a connected Wave account either through the Truto dashboard or programmatically via the API.

**Via the Truto UI:**
1. Navigate to the integrated account page for the specific Wave connection.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your desired configuration (e.g., name, method filters, tool tags).
5. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4e5f6...`).

**Via the API:**
If you are building an automated onboarding flow, you can provision the MCP server via a simple POST request. This creates the server, securely hashes the token, and returns the endpoint URL.

```bash
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": "Wave Finance AI Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["accounting", "billing"]
    }
  }'
```

The response will contain the `url` required for ChatGPT:

```json
{
  "id": "mcp_12345abcde",
  "name": "Wave Finance AI Agent",
  "config": { "methods": ["read", "write"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

### Step 2: Connect the MCP Server to ChatGPT

Once you have the Truto MCP URL, you simply point your ChatGPT instance to it.

**Via the ChatGPT UI (For ChatGPT Plus/Pro/Enterprise):**
1. Open ChatGPT and navigate to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode** (MCP support requires this flag to be active).
3. Under **MCP servers / Custom connectors**, click add.
4. Enter a name (e.g., "Wave Accounting Data").
5. Paste the Truto MCP server URL into the **Server URL** field.
6. Click **Save**.

ChatGPT will perform an MCP handshake, retrieve the server capabilities, and instantly populate its context with the available Wave tools.

**Via Manual Configuration (Custom AI Agents / Local Testing):**
If you are running a custom agent framework, you can connect using the official `@modelcontextprotocol/server-sse` transport package. Pass the Truto URL as an argument:

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

## Hero Tools for Wave

Once connected, ChatGPT gains access to the Wave API via dynamically generated tools. Here are the highest-leverage tools available for automating accounting operations.

### create_a_wave_invoice
Creates a new invoice inside Wave. This tool abstracts the `invoiceCreate` GraphQL mutation. It requires the `businessId` and `customerId`. 

*Usage Note:* The LLM should be instructed to check the `inputErrors` array in the response to ensure no field-level validation rules were violated.

> "Draft a new invoice for Acme Corp. Use my primary business ID. Include two line items: 'Consulting Retainer' for $5000 and 'Server Hosting' for $250. Let me know the new invoice number when it is ready."

### wave_invoices_send
Sends an existing Wave invoice to the customer via email. This relies on the `invoiceSend` mutation and requires the `Business.emailSendEnabled` flag to be active on the Wave account.

*Usage Note:* You must provide the `invoiceId` and target email addresses in the `to` field.

> "Take invoice INV-2026-042 and email it to billing@acmecorp.com. CC myself on the email, and attach the PDF version of the invoice."

### wave_estimates_convert_to_invoice
Converts an approved estimate directly into a draft invoice via the `convertEstimateToInvoice` mutation.

*Usage Note:* This is highly useful in approval workflows. The tool requires the `estimateId` and returns the new `invoiceId` alongside a boolean `didSucceed` flag.

> "The client just approved Estimate EST-109. Please convert that estimate into a formal invoice now."

### create_a_wave_customer
Creates a new customer record in Wave via the `customerCreate` mutation.

*Usage Note:* Requires `businessId` and `name`. If you need to populate deep fields (like shipping addresses or tax IDs), the LLM will map them based on the provided JSON schema.

> "Create a new customer profile for 'Globex Corporation'. Set their primary contact email to accounts@globex.com and their currency to USD."

### create_a_wave_money_transaction
Records a money transaction (BETA). This uses the `moneyTransactionCreate` mutation.

*Usage Note:* This tool requires the target Wave business to have `isClassicAccounting` set to false. It requires `businessId`, `externalId`, `date`, `description`, `anchor`, and `lineItems`.

> "Log a new money transaction for a $1,200 incoming wire transfer from Globex Corporation. Date it for today, and use 'Q3 Retainer Deposit' as the description."

### list_all_wave_businesses
Retrieves the businesses associated with the authenticated Wave user. 

*Usage Note:* Because nearly all write operations in Wave require a `businessId`, this tool is typically the first operation an LLM calls to establish the correct context for subsequent actions.

> "List all the businesses attached to this Wave account. I need the business ID for the one named 'Primary Consulting LLC' so we can generate some invoices."

To view the complete inventory of available Wave tools, endpoint schemas, and data models, review the [Wave integration page](https://truto.one/integrations/detail/wave).

## Workflows in Action

When you give ChatGPT access to these tools, it can orchestrate multi-step accounting workflows autonomously. Here are two real-world scenarios.

### Scenario 1: Estimate Approval and Billing

Sales teams often finalize deals in email or Slack, leaving finance teams to manually update the accounting system. ChatGPT can automate this transition.

> "The client just emailed confirming they want to proceed with Estimate EST-884. Mark it as accepted, convert it to an invoice, and email the invoice to their billing contact."

**Execution Steps:**
1. **`wave_estimates_mark_accepted`**: ChatGPT flags the estimate as accepted in the system.
2. **`wave_estimates_convert_to_invoice`**: The LLM converts the accepted estimate into an active invoice, retrieving the newly generated `invoiceId`.
3. **`wave_invoices_send`**: Using the new `invoiceId`, ChatGPT triggers Wave to email the final document to the client.

**Result:** The LLM responds: "I have marked Estimate EST-884 as accepted. It has been converted to Invoice INV-0199, and the final document has been emailed to the customer."

### Scenario 2: Automated Client Onboarding and Retainer

Setting up new accounts requires creating entities in a specific order due to relational foreign keys.

> "We just signed Initech. Create a new Wave customer profile for them. Then, draft an invoice for their initial $10,000 onboarding retainer and let me know the invoice ID so I can review it."

**Execution Steps:**
1. **`list_all_wave_businesses`**: ChatGPT fetches the default `businessId` required for all subsequent calls.
2. **`create_a_wave_customer`**: The LLM creates the Initech profile using the `businessId`, returning the new `customerId`.
3. **`create_a_wave_invoice`**: ChatGPT drafts the $10,000 invoice linking the `businessId` and `customerId`.

**Result:** The LLM handles the relational mapping in the background and replies: "Initech has been added as a customer (ID: 9982). I have drafted the onboarding retainer invoice, which is saved as INV-0200. It is currently in draft status pending your review."

## Security and Access Control

Giving an AI agent raw access to accounting ledgers requires strict governance. Truto MCP servers provide several layers of access control out of the box:

*   **Method Filtering:** Restrict an MCP server to only perform specific operations. Set `config.methods: ["read"]` to ensure ChatGPT can only query data (like reading estimates) but cannot execute destructive mutations (like deleting invoices).
*   **Tag Filtering:** Group tools by functional area. Set `config.tags: ["invoicing"]` to limit the LLM's access strictly to invoice-related endpoints, preventing it from touching core Chart of Accounts data.
*   **Expiration (Time-To-Live):** Use the `expires_at` property when creating the server. This is perfect for granting temporary agent access for end-of-month reconciliations. Once the Unix timestamp passes, the server URL is cryptographically invalidated.
*   **API Token Authentication:** By default, the MCP token in the URL handles authentication. For high-security environments, enable `require_api_token_auth: true`. This forces the ChatGPT client to also pass a valid Truto API token in the `Authorization` header, ensuring zero-trust access even if the URL leaks.

## Architecting for Scale

Connecting Wave to ChatGPT is not about writing a few API wrappers; it is about managing state, enforcing validation rules, and maintaining a robust infrastructure layer. By using a managed MCP server, you offload the complexity of Wave's GraphQL mutations, pagination schemas, and error formatting.

Instead of wasting engineering cycles reading Wave documentation and maintaining boilerplate REST adapters, your team can focus on designing the prompts and workflow logic that actually deliver business value.

> Stop building custom integrations in-house. Let Truto generate secure, AI-ready MCP servers for Wave and 100+ other SaaS platforms instantly.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)