How to Connect QuickBooks Online to Claude

Claude is the home game for this setup. Anthropic, the company behind Claude, created the Model Context Protocol, the open standard that lets an AI assistant use outside tools. So when you connect QuickBooks Online to Claude, you're not bolting on a workaround. You're using the feature the way it was designed to work.

That shows up in two places. Claude Desktop reads MCP servers from one JSON config file. Claude Code, the terminal version, adds one with a single command. There's no connector mode to switch on and no developer toggle to hunt for. ChatGPT gets there too, but through a different door: developer-mode connectors or a hosted middle layer. We cover that whole path separately in the ChatGPT version of this guide.

This one is Claude-only. We'll set up Intuit's official QuickBooks Online MCP server once, wire it into Claude Desktop and Claude Code, run first prompts a bookkeeper would actually use, and lock the whole thing down so a chat model can't touch a client's live books. And we'll be straight about the limit up front: this connection reads and queries. It does not close your books.

How do you connect QuickBooks Online to Claude?

Install Intuit's official open-source QuickBooks Online MCP server on your computer. It exposes 144 tools across 29 entity types and 11 financial reports. Register an app on the Intuit Developer Portal to get OAuth 2.0 credentials: a client ID, client secret, refresh token, and realm ID. Then wire the server into Claude Desktop through claude_desktop_config.json, or into Claude Code with the claude mcp add command. Claude supports MCP servers natively, so there's no connector or plugin layer to configure. One catch: the server runs locally, so claude.ai in a browser can't reach it. You need Claude Desktop or Claude Code.

Key Takeaways

• Claude speaks MCP natively. Anthropic created the protocol. Claude Desktop uses a config file, Claude Code uses one CLI command, and no connector layer sits between.
• One Intuit setup feeds both surfaces. Same server, same four credentials (client ID, client secret, refresh token, realm ID), two configs.
• Sandbox is easy, production has a wall. Sandbox accepts http://localhost:8000/callback. Production rejects localhost and needs a public HTTPS callback for the one-time OAuth handshake.
• The connection is long-lived. After the handshake, the server runs locally until the 100-day refresh window lapses. Then you re-authorize.
• Read-only is three flags away. Set QUICKBOOKS_DISABLE_WRITE, QUICKBOOKS_DISABLE_UPDATE, and QUICKBOOKS_DISABLE_DELETE to "true". Read tools stay available; write tools disappear.
• The pipe isn't the bookkeeper. A connected Claude can read and query your books. It can't do the judgment work. That gap is where a purpose-built tool earns its keep.

Why Claude is the natural home for a Claude QuickBooks MCP setup

MCP, the Model Context Protocol, is an open standard that Anthropic introduced. It gives an AI assistant a common way to call outside tools. Intuit built its official QuickBooks Online server on that standard. Which means a Claude QuickBooks MCP setup is the shortest distance between the two: the model's own maker wrote the protocol the server speaks.

That's not just trivia. It changes the setup. In Claude, there's no store to browse, no connector to enable, no approval queue. You describe the server in a config, restart, and the tools are there.

Native support vs connector mode

In Claude, an MCP server is a first-class citizen. You point Claude Desktop at the server in its config file, restart the app, and the QuickBooks tools show up in the tools list. Claude Code does the same from the terminal. ChatGPT's route runs through developer-mode connectors instead, which adds a layer with its own rules. If ChatGPT is where you work, follow the ChatGPT version of this guide; the Intuit steps are the same, but the wiring is different. And if you're still picking which assistant to use for this work at all, our Claude vs ChatGPT for bookkeeping comparison takes that question head-on.

The web wall applies to Claude too

One honest limit before you start. The official server is a local program. It runs on your machine. Claude in a browser at claude.ai runs in the cloud, and it cannot reach a process on your laptop. So this guide is for the two local surfaces: Claude Desktop and Claude Code. You can't connect QuickBooks to Claude in a browser this way, so if browser-only is a hard requirement for you, a raw local setup isn't your path.

What you're installing: Intuit's official server in one minute

Intuit publishes an official, open-source QuickBooks Online MCP server on GitHub. The numbers tell you what you're handling:

• 144 tools in total, spanning create, read, update, delete, and search.
• 29 entity types with full CRUD: invoices, bills, customers, vendors, journal entries, deposits, and more.
• 11 financial reports, including Profit and Loss, Balance Sheet, and Cash Flow.
• 396 tests behind the codebase.

The read tools are the safe majority: every get_* and search_* tool, plus the reports. The write tools (create_*, update_*, delete_*) are the risk surface. The server ships three flags that switch those categories off in bulk, and we'll use them.

Authentication is OAuth 2.0 through an app you register on the Intuit Developer Portal. The server needs four values in its environment: a client ID, a client secret, a refresh token, and a QUICKBOOKS_REALM_ID, which is your company's ID. There are no per-user API keys. The app registration is the only door in.

Claude Desktop or Claude Code? Pick your surface first

The Intuit half of the setup is identical either way. The Claude half depends on which surface you use.

Both point at the same built server and the same credentials. You can wire both on one machine and they won't fight. If you're not sure, start with Claude Desktop. It's the surface most bookkeepers already have open.

Step 1: The Intuit side (you do this once)

This half is the same no matter which Claude surface you pick, and it's one-time per company. Here's the condensed run.

Register an app on the Intuit Developer Portal

Intuit doesn't issue personal API keys. Every connection starts with an app you register yourself.

1. Create an account at the Intuit Developer Portal and create a new app.
2. In the app's settings, add http://localhost:8000/callback as a redirect URI. That covers sandbox.
3. Copy the client ID and client secret from the app's keys page.

Treat the secret like a password. It's one half of the key to your books.

Clone, build, authorize

1git clone https://github.com/intuit/quickbooks-online-mcp-server.git
2cd quickbooks-online-mcp-server
3npm install
4npm run build
Copy

Copy .env.example to .env and fill in the client ID, the client secret, and QUICKBOOKS_ENVIRONMENT=sandbox. Then run the handshake:

1npm run auth
Copy

Your browser opens, you sign in to a sandbox company, and you approve access. The server captures the refresh token and realm ID and writes them into .env for you. One pitfall worth knowing: the server looks for .env next to its compiled code, not in whatever folder your terminal happens to be in. If your tokens seem to vanish, check where the file actually sits.

The production wall, and why it's a one-time climb

Sandbox accepts a localhost redirect. Production does not. To authorize a real company, Intuit requires a public HTTPS callback for the browser handshake. Most people solve it with an ngrok tunnel. A small public callback endpoint works too. Either way, it's a one-time step. Once the handshake completes, the server runs locally until the 100-day refresh window lapses. If it ever does lapse, you re-run the handshake and you're back in.

Step 2A: Connect QuickBooks Online to Claude Desktop

This is the part most guides rush, and it's where Claude differs from everything else. Claude Desktop reads its MCP servers from one file: claude_desktop_config.json.

To find it, open Claude Desktop, go to Settings, then Developer, and choose to edit the config. Or open the file directly:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

The Intuit README ships an mcpServers block for exactly this. Here's the shape, set up the way we recommend for a first connection:

1{
2  "mcpServers": {
3    "quickbooks": {
4      "command": "node",
5      "args": ["/path/to/quickbooks-online-mcp-server/dist/index.js"],
6      "env": {
7        "QUICKBOOKS_CLIENT_ID": "your_client_id",
8        "QUICKBOOKS_CLIENT_SECRET": "your_client_secret",
9        "QUICKBOOKS_REFRESH_TOKEN": "your_refresh_token",
10        "QUICKBOOKS_REALM_ID": "your_realm_id",
11        "QUICKBOOKS_ENVIRONMENT": "sandbox",
12        "QUICKBOOKS_DISABLE_WRITE": "true",
13        "QUICKBOOKS_DISABLE_UPDATE": "true",
14        "QUICKBOOKS_DISABLE_DELETE": "true"
15      }
16    }
17  }
18}
Copy

Save the file and restart Claude Desktop. The QuickBooks tools appear in Claude's tools list. That's the whole Desktop side: one file, one restart.

The read-only config, spelled out

Look at the last three lines of that env block. QUICKBOOKS_DISABLE_WRITE, QUICKBOOKS_DISABLE_UPDATE, and QUICKBOOKS_DISABLE_DELETE are set to "true". With those flags on, the write tools never register. Claude can't call a tool it can't see. The read tools, every get_* and search_* plus the reports, stay available. This is the posture to keep for any client's books, and honestly for your own until you've watched the model work for a while. Loosen one flag at a time, and only with a reason.

Step 2B: Claude Code, one command in the terminal

Claude Code, the CLI version of Claude, registers MCP servers with the claude mcp add family of commands. The quick form wires a simple server in one line. For this server, claude mcp add-json is the better fit, because it takes the same JSON block the Desktop config uses, env vars and all:

1claude mcp add-json quickbooks '{
2  "command": "node",
3  "args": ["/path/to/quickbooks-online-mcp-server/dist/index.js"],
4  "env": {
5    "QUICKBOOKS_CLIENT_ID": "your_client_id",
6    "QUICKBOOKS_CLIENT_SECRET": "your_client_secret",
7    "QUICKBOOKS_REFRESH_TOKEN": "your_refresh_token",
8    "QUICKBOOKS_REALM_ID": "your_realm_id",
9    "QUICKBOOKS_ENVIRONMENT": "sandbox",
10    "QUICKBOOKS_DISABLE_WRITE": "true",
11    "QUICKBOOKS_DISABLE_UPDATE": "true",
12    "QUICKBOOKS_DISABLE_DELETE": "true"
13  }
14}'
Copy

Start a new Claude Code session and the QuickBooks tools are available. Two notes. First, claude mcp add also has --transport http and --transport sse variants. Those are for remote servers, and this one is local, so you won't need them here. Second, both surfaces can share one build. Set the server up once, give Desktop and Code the same path and the same env values, and there's one .env behind both.

First prompts: put Claude to work on your books

Start with a prompt that reads and changes nothing, to prove the wiring:

Using the QuickBooks tools, pull my company info and this month's Profit and Loss.

If real numbers come back, the connection works. From there, here are prompts a bookkeeper would actually run, all safe under the read-only flags:

Pull the trial balance and list any account whose balance flipped sign since last month.

Search this month's uncategorized transactions and group them by payee. Tell me which payees repeat, and which account you'd suggest for each. Don't change anything.

Get the aged payables report and flag every bill due within the next 7 days.

List this month's deposits over $1,000 and show which customer payments each one includes.

Notice the shape of the second prompt: suggest, don't do. Keep that habit even if you eventually turn write access on. Have Claude propose the change, show its work, and wait for your yes. For a deeper set of workflows once you're connected, see our guide on how to use Claude for bookkeeping.

Keep client books safe: the read-only posture

A short, serious checklist before this touches anything real:

• Client books get read-only, full stop. All three disable flags stay "true". If a task truly needs a write, run that task in sandbox first, watch the behavior, then decide.
• Sandbox before production, every time. The developer portal gives you a free fake company. New prompt, new workflow, new flag: sandbox first.
• Your config file is plain text. The env block in claude_desktop_config.json holds your client secret and refresh token. Anyone who can read that file can read your keys. Don't commit it, don't screenshot it, don't share it.
• The refresh token is the crown jewel. It's what keeps the connection alive, and it rotates on its own. Let the server manage it inside .env, and don't copy it around.
• Writes need a human. Even with flags loosened, Claude proposes and you approve. QuickBooks records that a change happened. It doesn't record why, or that an AI made it. For anything that might get reviewed later, that missing "why" becomes your problem.
• Client data carries a higher bar. Whatever Claude reads through the connection is processed like any chat content. Know your confidentiality obligations before you authorize a client's realm.

What the connection won't do (and what to do about it)

Now the part the setup posts skip.

Everything above gives Claude access. It does not give Claude judgment. MCP reads and queries; it does not close your books. A connected model has the buttons and none of the sense about which button is right:

• A payment-processor deposit lands as one number with the fees already taken out. Book it gross and your revenue is overstated. Knowing to net it out is an accounting decision, not a data lookup.
• A transfer between accounts can look exactly like income in a bank feed. Guess wrong and you've inflated revenue and bought yourself a tax problem.
• A bank line that reads "ACH PAYMENT 847293847" gives a model nothing to work with. A bookkeeper reads the date, the amount, and the history, and often still asks the client.

And Claude starts every session cold. Correct it today, and tomorrow it holds no memory of the correction. Each client's quirks have to be re-taught every time. Switching assistants doesn't fix it either; we compared ChatGPT vs Claude for accounting, and the judgment gap holds on both sides.

So treat the connection for what it is: a very good pipe. For asking questions of your books, it's genuinely useful, and you should use it. For doing the books, the pipe is where the problem starts.

That gap is the job Growthy was built for. Instead of a developer portal and a config file, you connect QuickBooks Online with a normal OAuth sign-in. That connection is live in the alpha today, and the alpha is free. Growthy handles the routine categorization at 85% accuracy on a first import, and you review the rest. It flags what it isn't sure about instead of burying you in everything to re-check. Your corrections carry forward per client through pattern learning, so the same fix doesn't need re-teaching next month. Every change runs through review-and-approve, so nothing posts that you didn't sign off on. And the piece people ask about most, a conversational accounting director that makes adjustments from chat, is in active development and testing now. Connecting early puts you in line for it when it ships.

See it against your own books. Book a demo, connect QuickBooks Online in a couple of clicks, and watch the routine categorization come off your plate. Book a demo.

Frequently asked questions

Where is the claude_desktop_config.json file?

Open Claude Desktop, go to Settings, then Developer, and choose to edit the config. On macOS the file lives at ~/Library/Application Support/Claude/claude_desktop_config.json. On Windows it's %APPDATA%\Claude\claude_desktop_config.json. If the file doesn't exist yet, creating it through Settings puts it in the right place.

What's the difference between Claude Desktop and Claude Code for QuickBooks work?

Same server, different surface. Claude Desktop is a chat app that loads MCP servers from claude_desktop_config.json, which suits review-style work: asking questions, reading reports. Claude Code is a terminal tool that registers servers with claude mcp add, which suits scripted, repeatable setups. Both use the same credentials and the same local build.

Can Claude Desktop and Claude Code share one QuickBooks server setup?

Yes. Build the Intuit server once, then give both surfaces the same dist/index.js path and the same environment values. Each starts the server when it needs it, and both read the same .env, so your tokens stay in one place.

Does this work with Claude in the browser?

No. The official Intuit server runs locally on your machine, and claude.ai in a browser runs in the cloud. A web page can't reach a local process. You need Claude Desktop or Claude Code. That's a property of local MCP servers in general, not a setting you can change.

How do I keep Claude read-only in my books?

Set QUICKBOOKS_DISABLE_WRITE, QUICKBOOKS_DISABLE_UPDATE, and QUICKBOOKS_DISABLE_DELETE to "true" in the server's env block. Those flags stop the write tools from registering at all, so Claude can't see or call them. Every get_* and search_* tool, plus the 11 reports, keeps working. It's the right posture for client books.

When should I use claude mcp add-json instead of claude mcp add?

Use add-json when the server needs a longer config, like this one with its eight environment variables. It accepts the same JSON block the Desktop config uses, so one canonical config serves both surfaces. Plain claude mcp add is the quick form for simple servers, and the --transport http and --transport sse variants are for remote servers.

Why doesn't Claude need a connector the way ChatGPT does?

Anthropic created the Model Context Protocol, and Claude supports MCP servers natively in both Desktop and Code. ChatGPT reaches outside tools through its developer-mode connector path, which is a separate setup with its own rules. The Intuit server is the same either way; only the wiring differs. The ChatGPT version of this guide walks that other path.

Do I have to redo the OAuth handshake every time I open Claude?

No. The handshake is one-time per company. After it, the refresh token keeps the server connected, and it runs locally until the 100-day refresh window lapses. If the window does lapse, run npm run auth again and you're reconnected.

Does Claude send my QuickBooks data to Anthropic?

Anything Claude reads through the connection is processed by the model, the same as text you paste into a chat. Review Anthropic's data terms and your own confidentiality obligations before connecting books you don't own. For client work, keep the connection read-only and be deliberate about which realm you authorize.

Which Claude model should I use for bookkeeping work?

The connection works the same across Claude's models, because MCP tools don't depend on which model answers. Model choice affects reasoning on hard prompts, not access. Start with the default model in Claude Desktop, and don't expect a model upgrade to close the judgment gap. Knowing net from gross isn't a model-size problem.

The short version: connect QuickBooks Online to Claude with Intuit's official server, keep the flags read-only, and let Claude answer the questions your books have been hiding. Then be honest about the ceiling. Access isn't judgment, and a pipe isn't a bookkeeper. For the routine work itself, bring a tool that was built to do it, checked by you. And if your work runs to the tax side, the same operator stack covers that through our sister product for tax workpaper automation, TracePrep.

Growthy is bookkeeping software, not a CPA firm. This content is educational, not professional advice.