# How to Connect an AI Agent to QuickBooks: Build Your Own AI Finance Assistant

> Source: <https://getbruin.com/blog/connect-ai-agent-to-quickbooks/>
> Published: 2026-10-02 00:00:00+00:00

**Quick answer:** To connect an AI agent to QuickBooks, split reads from writes. Load QuickBooks Online into BigQuery or a local DuckDB file with the open-source [QuickBooks template for Bruin](https://github.com/bruin-data/bruin/tree/main/templates/quickbooks-bigquery). It models P&L, MRR, AR aging, vendor spend, runway, and an expense review queue. Point Claude Code, Codex, or Cursor at those tables with a context layer. Then add Intuit's open-source [QuickBooks Online MCP server](https://github.com/intuit/quickbooks-online-mcp-server) so the agent can update and create records in QuickBooks after you approve each change. The [step-by-step tutorial](https://getbruin.com/learn/quickbooks-ai-agent/) covers both the BigQuery and local DuckDB paths.

Most small finance teams ask the same questions every week. Who owes us money? What did we spend on software last quarter? How many months of runway do we have? What still needs categorizing before close?

QuickBooks holds every answer. Getting them out quickly, in your own definitions, is the part that costs extra.

## [What QuickBooks puts behind higher tiers](#what-quickbooks-puts-behind-higher-tiers)

QuickBooks Online's plans scale reporting and AI with the price. Here is how Intuit's [US pricing page](https://quickbooks.intuit.com/pricing/) describes the plans as of October 2026:

| Plan | List price per month | Reporting | AI and automation | 
|---|---|---|---|
| Simple Start | $38 | "Run general business reports" | AI chat with limited capacity (beta), expense categorization | 
| Essentials | $85 | "Run enhanced reports" | Accounting AI, Payments AI | 
| Plus | $140 | "Run comprehensive reports", budgets, class and location tracking | Scenario planning chat (beta), Sales Tax AI, Customer AI | 
| Advanced | $340 | Customizable dashboards with personalized KPIs, unlimited custom KPIs, Spreadsheet Sync with Excel | Finance AI, Project Management AI, automated workflows | 

Prices change and promotions come and go, so check the page for your region. The pattern is what matters. Custom dashboards, financial insights from AI, and automation sit at the top, at roughly nine times the price of the entry plan.

For a seed-stage company or a small agency, that is a lot to pay for a dashboard and a chat box. It also doesn't solve the bigger problem. Even on Advanced, the definitions live inside QuickBooks. You cannot join them to your CRM or billing system, version them in Git, or test them.

## [Three ways to connect AI to QuickBooks](#three-ways-to-connect-ai-to-quickbooks)

There are now three practical options. They solve different problems.

|  | QuickBooks connector in Claude or ChatGPT | QuickBooks MCP server on its own | Pipeline + context layer + MCP | 
|---|---|---|---|
| **Setup** | Enable it in the chat app | Intuit developer app, local server | Pipeline, warehouse or DuckDB, local server | 
| **Reads from** | Your live company | Your live company, through the API | Modelled tables with history | 
| **Your own metric definitions** | No | No | Yes, in SQL and a mapping file | 
| **Join with other data** | No | No | Yes | 
| **Custom reports and dashboards** | In chat | In chat | Saved as tested SQL assets and dashboard files | 
| **Write actions** | Invoicing, estimates, customers, and more, as Intuit adds them | 140+ tools, which you can switch off by type | Same MCP tools, under an approval skill | 
| **Runs where** | Vendor cloud | Your machine | Your machine, your warehouse | 

**The hosted connectors** are the fastest start. Intuit's [QuickBooks connector for Claude](https://quickbooks.intuit.com/learn-support/en-us/help-article/accounting-bookkeeping/use-quickbooks-connector-claude/L3YBlo6Ht_US_en_US) and the [QuickBooks app in ChatGPT](https://openai.com/business/plugins/quickbooks/) can generate reports, create invoices, and add customers from a chat. If your questions fit what QuickBooks already reports, start there.

**The MCP server** gives a coding agent the full QuickBooks API surface on your own machine. It is great for actions. It is a weak analytics layer on its own. Every question becomes a sequence of API reads over current records. Each answer depends on how the agent decides to compute MRR that day. Intuit also rate-limits the API per company and meters some call types on its free developer tier, so a read-heavy agent runs into limits a warehouse never has.

**The pipeline approach** puts a modelled copy of your books between the agent and the API. Reads come from tables with fixed definitions and checks. Writes still go through the MCP server. This is the one to build when the numbers need to be right every time, and it is what the rest of this post covers.

## [The architecture: read from models, write through MCP](#the-architecture-read-from-models-write-through-mcp)

``` php
QuickBooks Online --ingestr--> quickbooks_raw --SQL--> quickbooks_stage --SQL--> quickbooks_reports
       ^                                                                              |
       |                                                                       context layer
       |                                                                              v
 QuickBooks MCP  <-------------- approved change <-------------- AI agent (Claude Code / Codex / Cursor)
```

Four parts:

1. **An ELT pipeline.**[ingestr](https://github.com/bruin-data/ingestr) loads seven QuickBooks objects: customers, vendors, accounts, invoices, payments, purchases, and bills.[Bruin](https://github.com/bruin-data/bruin) then builds typed staging tables and nine finance reports. Daily runs pick up only records changed since the last run.
2. **A modelled finance layer.** P&L lines come from an editable chart-of-accounts mapping CSV. MRR counts only accounts you mark recurring. Custom checks reconcile the P&L to source lines, the MRR bridge month over month, and AR aging to the A/R account balance.
3. **A context layer.** Every table and column is documented in the asset files. Each report lists the questions it answers and notes for agents. The template ships an`AGENTS.md` with metric definitions and three workflows: month-end review, categorizing transactions, and finding duplicates and spikes. You add your company's own rules on top.
4. **Approved actions.** Intuit's MCP server handles writes. A skill file tells the agent to propose, wait, apply, and verify.

The separation matters for accuracy. If the agent computes runway from raw API calls, it has to invent a definition every time. If it reads `quickbooks_reports.cash_runway`, the definition is fixed and documented: bank balance divided by the average net burn of the last three closed months. Every answer uses the same number, and the agent can say it is an estimate.

## [Quick answers in your definitions](#quick-answers-in-your-definitions)

With the context layer in place, the questions from the top of this post become one-line prompts:

- "Who owes us money, and how overdue is it?" reads `ar_aging` , grouped by customer
- "What did we spend on software last quarter, and which tools are new?" reads `vendor_spend` and its new-vendor flag
- "What's our runway, and how confident should I be?" reads `cash_runway` and explains the inputs
- "Which customers churned or contracted last month?" reads `customer_mrr_movements`

The agent shows the SQL it ran, names the month a number is for, and flags months whose books are still open. When it gets something wrong, you fix the rule once in `AGENTS.md`. Every later answer picks it up.

Context also covers what the pipeline cannot see. If your payroll is booked as journal entries, or Stripe revenue syncs as deposits, those amounts are missing from the modelled P&L. One line in `AGENTS.md` makes the agent say so. Without it, you get a burn number that looks plausible and is wrong.

## [Custom reports and dashboards](#custom-reports-and-dashboards)

On the QuickBooks side, custom dashboards are an Advanced feature. Here, a custom report is a SQL file the agent writes for you:

Add a monthly department P&L report from `monthly_pnl`, one row per month and department. Document every column, add a check that it reconciles to `monthly_kpis`, show me the SQL, then run it.

The result is a pipeline asset. It rebuilds every day, carries its own checks, and goes through code review like any other change. A budget-versus-actual report is a CSV of budget rows plus a join. A cash forecast is open AR by each customer's average days to pay, against open bills by due date.

The template also ships a five-tab dashboard built with [Dashboards as Code](https://getbruin.com/docs/dac/getting-started/installation.html): Overview, Revenue, Spend, Cash & AR, and Review Queue. The dashboard is a YAML file, so the agent can add a tab the same way it adds a report. Dashboards and chat answers read from the same tables, so they agree.

## [Taking actions in QuickBooks](#taking-actions-in-quickbooks)

Answers are half the job. The other half is fixing the books, and that is where most "AI for QuickBooks" setups stop at a suggestion.

Take uncategorized transactions. The pipeline's `expense_review_queue` already flags uncategorized lines, possible duplicates, amount spikes, unusual accounts, and first-time vendors. Where the payee's history allows, it suggests an account and a confidence score. The workflow looks like this:

1. The agent reads the queue from the warehouse and proposes an account for each line, marked high-confidence or unsure.
2. You approve the high-confidence rows.
3. The agent reads each purchase or bill through the MCP server, changes only the account on that line, and writes it back with the current sync token.
4. The next pipeline run reloads the edited records, and the lines leave the queue. If one is still there, the change did not land.

The same pattern covers creating the month's invoices from last month's recurring lines, adding notes to overdue customers, and cleaning up vendor terms and 1099 flags.

Writes need controls. These are the ones worth having from day one:

- **Sandbox first.** Every Intuit developer account includes a sandbox company. Prove each workflow there.
- **A separate Intuit app for the agent.** You can revoke the agent without breaking the nightly data load, and QuickBooks' audit log shows which app made each change.
- **Tools off by default.** The MCP server's`QUICKBOOKS_DISABLE_WRITE` ,`QUICKBOOKS_DISABLE_UPDATE` , and`QUICKBOOKS_DISABLE_DELETE` flags keep those tools from being registered at all. Recategorizing needs updates only.
- **Approval in the skill.** The agent proposes a table of changes and waits. It never touches closed periods, payroll, or tax, and it never deletes without the record id typed back.
- **A person on money movement.** Bill payments and anything that leaves the bank stay a human click in QuickBooks.

## [Local or warehouse](#local-or-warehouse)

The tutorial supports two paths with the same pipeline:

- **BigQuery** is the template's native target. Choose it when the finance data should join CRM, billing, or product data, or when more than one person will use it.
- **DuckDB** keeps everything in one file on your laptop. Choose it when a founder or bookkeeper wants the whole setup on one machine with no cloud account.

Either way, the agent runs locally in Claude Code, Codex, or Cursor, on the model subscription you already have. When the rest of the team wants answers, [Bruin Cloud](https://getbruin.com/learn/cloud-ai-agent/) can run the same pipeline on a schedule. It serves the same context layer as an AI analyst in Slack, Microsoft Teams, or the browser, with lineage, access controls, and audit logs. [Bruin for finance teams](https://getbruin.com/solutions/finance-teams/) covers the managed setup.

## [Get started](#get-started)

The [QuickBooks AI agent tutorial](https://getbruin.com/learn/quickbooks-ai-agent/) walks through the full setup in seven steps:

1. Copy the template from GitHub and choose BigQuery or DuckDB
2. Load and model your QuickBooks data
3. Map your chart of accounts and reconcile with the QuickBooks P&L
4. Build the context layer and connect the Bruin MCP
5. Ask questions, build reports, and extend the dashboard
6. Connect the QuickBooks MCP server and add the approval skill
7. Schedule the pipeline and share the analyst

Everything in it is open source: the pipeline template, ingestr, Bruin, DAC, and Intuit's MCP server. You need a paid QuickBooks Online plan or an Intuit sandbox company, and a coding agent.