Build an AI Bookkeeping System with QuickBooks and Make.com: The Complete Step-by-Step Guide

Manual bookkeeping is for agencies that want to stay small forever. If you want to run an AI bookkeeping operation that generates $10,000+/month in recurring revenue, you need an automated engine that imports transactions, categorizes them with AI, reconciles bank statements, detects anomalies, and generates client-ready financial reports — all without you touching a keyboard after the initial setup. This guide is the technical implementation manual. Follow every step in order. Skip nothing. If you skip the categorization prompt engineering, your AI sends wrong categories that compound into bad financials. If you skip the reconciliation check, mismatched transactions silently corrupt the books. Every step exists because someone lost a client by skipping it.

This guide assumes you have zero infrastructure set up. By the end, you’ll have a fully automated pipeline that can handle 10+ clients simultaneously with minimal manual intervention.

Prerequisites

Before you start, you need the following:

• QuickBooks Online Accountant — Free (sign up at quickbooks.intuit.com/accountants)
• Make .com — $16/mo (Teams plan for 10,000 operations/month)
• OpenAI API key — $10 credit minimum (platform.openai.com/api-keys)
• Google Workspace — $6/mo for professional email and Sheets access
• Dext — $15/mo (Starter plan for receipt and invoice capture)
• Notion — Free (client dashboards and documentation)
• 6-8 hours of uninterrupted time for initial setup

Total upfront cost: $47/mo + $10 API credit. A single client at $500/month covers this 10x over.

Step 1: Set Up Your Accounting Platform Integration

This is the most critical step. Without a reliable connection to your client’s accounting platform, nothing else works. You have two primary options: QuickBooks Online (most popular in the US) and Xero (popular internationally and with tech-savvy clients). Set up both so you can serve any client.

Sub-step 1a: QuickBooks Online Accountant Setup

Go to quickbooks.intuit.com/accountants and sign up for a free QuickBooks Online Accountant account. Complete the business verification process. You should see the QBO Accountant dashboard with a “Add client” button.

Click Add client and create your first test client. Choose “QuickBooks Online Plus” as the product (this gives you the most features for testing). Name it “Test Client — Bookkeeping Automation.” During setup, select “Services” as the industry — this is the simplest chart of accounts for testing.

After the client is created, navigate to Apps in the left sidebar. Search for “Make” and connect it. If Make doesn’t appear as a native integration, you’ll use the QuickBooks API directly through Make.com’s HTTP module.

Sub-step 1b: Generate QuickBooks API Credentials

Go to developer.intuit.com and create a new app. Select “QuickBooks Online and Payments” as the platform. Name your app “AI Bookkeeping Automation.” This gives you a Client ID and Client Secret.

In your app settings, set the redirect URI to: https://www.make.com/oauth/callback/quickbooks. Under “Scopes,” enable: com.intuit.quickbooks.accounting (full read/write access to accounting data).

Copy your Client ID and Client Secret into a secure document. You’ll need these for the Make.com connection.

Sub-step 1c: Connect QuickBooks to Make.com

Open Make.com. Go to Connections → Add connection. Search for “QuickBooks” and select the QuickBooks Online module. Enter your Client ID and Client Secret. Click Connect — this opens an Intuit authorization page. Authorize access to your test client’s QuickBooks company.

After authorization, the connection should show a green “Connected” status. Do you see this? If it shows red or yellow, verify your redirect URI matches exactly in both the Intuit developer portal and the Make.com connection settings.

Sub-step 1d: Xero Setup (Alternative/Additional)

If you also want Xero capability, go to developer.xero.com and create a new app. Set the redirect URI to: https://www.make.com/oauth/callback/xero. Under “Scopes,” enable: accounting.transactions, accounting.reports.read, and accounting.settings.read.

In Make.com, add a Xero connection using your Xero app credentials. Authorize access to your Xero organization. Verify the connection shows green.

Step 1 Check-In

Verify each of these before moving on:

1. QuickBooks Online Accountant account is active with a test client created
2. QBO API credentials generated and stored securely
3. Make.com QuickBooks connection shows green “Connected” status
4. Test API call works: In Make.com, create a test scenario with QuickBooks “Search Accounts” module — it should return your chart of accounts
5. (Optional) Xero connection also shows green

Step 2: Build the AI Categorization Engine

This is the heart of your bookkeeping automation. The categorization engine takes uncategorized transactions, sends them to OpenAI with the client’s chart of accounts, and writes the category back to the accounting platform. When it works, you process 1,000 transactions in 10 minutes. When it fails, you miscategorize expenses and corrupt the client’s financials.

Sub-step 2a: Create the Chart of Accounts Reference Sheet

In Google Sheets, create a new spreadsheet called “COA Reference — [Client Name].” This sheet stores the client’s chart of accounts in a format the AI can understand.

Column A: Account Name | Column B: Account Type | Column C: Description/Examples

Example rows:

Fill in 20-30 accounts that match the client’s actual business. The descriptions are critical — they help the AI understand what belongs in each category. Without descriptions, the AI has to guess based on the account name alone, which reduces accuracy by 15-20%.

Sub-step 2b: Build the Make.com Categorization Workflow

Create a new Make.com scenario called “AI Categorization — [Client Name]”:

1. Trigger: QuickBooks Online — “Watch Transactions” (polls every 6 hours for new uncategorized transactions). Configure: select your test client’s company, filter for transactions where Category is blank.

2. Module 1 — Google Sheets “Search Rows”: Look up the Chart of Accounts reference. This pulls the full COA list so the AI knows what categories are available.

3. Module 2 — OpenAI “Create a Chat Completion”:

   • Model: gpt-4o
   • System message:

You are a professional bookkeeper categorizing bank transactions. Given a transaction description and amount, assign it to exactly one category from the provided chart of accounts.

RULES:
- Match the transaction to the most specific category available
- If the description contains a known vendor name, use the vendor's typical category
- For amounts ending in .99 or .00 from known merchants, it's likely a subscription or regular bill
- If you cannot determine the category with confidence, respond with "Review Needed"
- Respond with ONLY the category name, nothing else

CHART OF ACCOUNTS:
{{1.values}}

• User message:

Transaction: {{2.description}}
Amount: {{2.amount}}
Date: {{2.date}}
Vendor: {{2.vendor}}

4. Module 3 — Router:

   • Path A: If OpenAI response equals “Review Needed” → Google Sheets “Add Row” to a “Review Queue” sheet + Slack notification to you
   • Path B: If OpenAI response is a category name → QuickBooks Online “Update Transaction” with the categorized account

5. Module 4 — Error Handler: On any OpenAI failure (rate limit, timeout), add a Break module with automatic retry (3 retries, 30-second interval). After the Break, add a Slack notification: “Categorization failed for transaction: {{2.description}}. Manual review required.”

Sub-step 2c: Test the Categorization Engine

Add 10 test transactions to your QuickBooks test client. Include a variety: an Amazon purchase, a Stripe fee, a restaurant charge, an Uber ride, a software subscription, a rent payment, and a few ambiguous ones. Run the Make.com scenario once.

Check QuickBooks: do the transactions now show categories? Check the Review Queue sheet: did the ambiguous transactions get flagged? Check Slack: did any error notifications appear?

Expected results: 8-9 out of 10 transactions categorized correctly. 1-2 flagged as “Review Needed.” If more than 2 are miscategorized, improve your COA descriptions. If none are flagged for review, your threshold is too permissive — you want the AI to be cautious, not aggressive.

Step 2 Check-In

1. Chart of Accounts reference sheet created with 20+ accounts and descriptions
2. Make.com categorization workflow processes test transactions correctly
3. AI categorization accuracy is 85%+ on test data
4. “Review Needed” transactions are flagged and routed correctly
5. Error handling catches API failures and notifies Slack

Step 3: Build the Bank Reconciliation Workflow

Categorization is useless if the books don’t match the bank. Reconciliation is the process of matching transactions in QuickBooks/Xero to transactions on the bank statement. Most bookkeepers do this manually at month-end. Your automation does it weekly (or even daily), catching discrepancies before they compound.

Sub-step 3a: Create the Reconciliation Make.com Scenario

Create a new scenario called “Bank Reconciliation — [Client Name]”:

1. Trigger: Schedule — runs every Monday at 7 AM
2. Module 1 — QuickBooks “List Transactions”: Pull all transactions from the past 7 days with status “Not Reconciled”
3. Module 2 — QuickBooks “List Bank Transactions”: Pull bank feed entries from the past 7 days
4. Module 3 — Array Aggregator: Combine both data sets into a single array for matching
5. Module 4 — OpenAI “Create a Chat Completion”:

System message:

You are a bank reconciliation specialist. Given two lists of transactions — one from the accounting system and one from the bank feed — match each bank transaction to the corresponding bookkeeping transaction.

MATCHING RULES:
- Match by amount (exact match required)
- Match by date (allow 1-3 day difference for processing delays)
- Match by vendor/description similarity (partial match is acceptable)
- A bank transaction can only match one bookkeeping transaction
- Unmatched transactions on either side are "exceptions"

Respond in JSON format:
{
  "matched": [{"bank_id": "x", "bookkeeping_id": "y", "confidence": 0.95}],
  "bank_exceptions": [{"id": "z", "description": "...", "amount": "..."}],
  "bookkeeping_exceptions": [{"id": "w", "description": "...", "amount": "..."}]
}

6. Module 5 — Parse JSON: Convert the OpenAI response into structured variables
7. Module 6 — QuickBooks “Update Transaction”: For each matched transaction, set the status to “Reconciled”
8. Module 7 — Google Sheets “Add Rows”: Log all exceptions (unmatched transactions) to an “Exceptions” sheet
9. Module 8 — Slack “Create Message”: Send a weekly reconciliation summary:

Weekly Reconciliation Summary — [Client Name]
Matched: 47 transactions
Bank exceptions: 3 (see Exceptions sheet)
Bookkeeping exceptions: 2 (see Exceptions sheet)
Action required: Review 5 exception transactions

Exception details:
- Bank: $2,450.00 from "WIRE TRANSFER" on 04/22 — no matching bookkeeping entry
- Bookkeeping: $89.99 "Adobe Creative Cloud" on 04/20 — no matching bank entry
- ...

Sub-step 3b: Handle Common Reconciliation Exceptions

Build a separate Make.com scenario for the most common exception types:

Duplicate transactions: When the same amount appears twice in the bookkeeping records within 3 days, flag one as a potential duplicate. OpenAI prompt: “Is this transaction likely a duplicate? Amount: {{amount}}, Date 1: {{date1}}, Date 2: {{date2}}, Description: {{desc}}. Reply DUPLICATE or LEGITIMATE with a brief explanation.”

Timing differences: When a bank transaction appears 2-5 days after the bookkeeping entry, flag it as a “timing difference” rather than an exception. This is normal for credit card processing and ACH transfers.

Missing entries: When a bank transaction has no matching bookkeeping entry, create a new uncategorized transaction in QuickBooks so it appears in the next categorization run.

Step 3 Check-In

1. Reconciliation scenario runs weekly and processes the past 7 days of transactions
2. Matched transactions are marked as “Reconciled” in QuickBooks
3. Exceptions are logged to the Exceptions sheet with full details
4. Slack summary arrives every Monday with a clear action list
5. Common exception types (duplicates, timing differences, missing entries) are handled automatically

Step 4: Build the Anomaly Detection and Alert System

Anomaly detection is what separates “automated data entry” from “strategic bookkeeping partnership.” This system flags unusual transactions that could indicate errors, fraud, or simply items that need human attention. Clients view this as a premium security feature — and it’s just a few conditional checks.

Sub-step 4a: Define Anomaly Rules

Create a Google Sheet called “Anomaly Rules — [Client Name]” with these rules:

Sub-step 4b: Build the Anomaly Detection Workflow

Create a new Make.com scenario called “Anomaly Detection — [Client Name]”:

1. Trigger: QuickBooks “Watch Transactions” (same trigger as categorization — combine them by adding anomaly checks to the categorization flow, or run as a separate daily check)

2. Module 1 — Google Sheets “Search Rows”: Pull the anomaly rules and the vendor mapping database

3. Module 2 — OpenAI “Create a Chat Completion”:

System message:

You are a bookkeeping anomaly detector. Given a transaction and context about the business, determine if this transaction is unusual or potentially problematic.

Check for:
1. Is the amount unusually large for this category? (Compare to typical range)
2. Is this a new vendor not previously seen?
3. Does the description suggest a personal expense rather than business?
4. Is the amount suspiciously round (e.g., exactly $5,000)?
5. Could this be a duplicate of a recent transaction?

Respond in JSON:
{
  "is_anomaly": true/false,
  "anomaly_type": "large_amount|new_vendor|personal_expense|round_amount|duplicate|none",
  "severity": "high|medium|low",
  "explanation": "Brief explanation of why this was flagged"
}

4. Module 3 — Router:
   • Path A (High Severity): Slack alert to #bookkeeping-alerts + Google Sheets log + email to client
   • Path B ( Medium Severity): Google Sheets log + Slack alert to you only
   • Path C (Low Severity): Google Sheets log only
   • Path D (No Anomaly): No action, transaction passes through normally

Step 4 Check-In

1. Anomaly rules sheet is created with 7+ rule types
2. Anomaly detection Make.com scenario processes test transactions correctly
3. High-severity anomalies trigger Slack alerts and client emails
4. All anomalies are logged in the anomaly tracking sheet
5. Test with a deliberately anomalous transaction ($5,000 at a grocery store) — verify it gets flagged as high severity

Step 5: Build the Monthly Close and Reporting Automation

This is where you justify your monthly retainer. Clients don’t pay you to categorize transactions — they pay you for the insight those transactions provide. The monthly close automation generates professional financial reports with AI-written narrative summaries that explain what the numbers mean.

Sub-step 5a: Create the Monthly Report Template

In Google Docs (or Notion), create a report template with these sections:

1. Executive Summary (1 paragraph — AI-generated narrative overview)
2. Profit & Loss Statement (pulled from QuickBooks/Xero)
3. Balance Sheet (pulled from QuickBooks/Xero)
4. Key Metrics Dashboard (calculated from transaction data)
5. Category Breakdown (top 5 expense categories with trend analysis)
6. Anomalies & Action Items (from the anomaly detection system)
7. Cash Flow Forecast (AI-generated projection for next 30 days)

Sub-step 5b: Build the Monthly Close Workflow

Create a new Make.com scenario called “Monthly Close — [Client Name]”:

1. Trigger: Schedule — runs on the 5th of each month at 6 AM
2. Module 1 — QuickBooks “Get Profit and Loss”: Pull the P&L for the previous month
3. Module 2 — QuickBooks “Get Balance Sheet”: Pull the Balance Sheet as of month-end
4. Module 3 — Google Sheets “Search Rows”: Pull the anomaly log for the previous month
5. Module 4 — OpenAI “Create a Chat Completion” (Narrative Summary):

System message:

You are a CFO writing a monthly financial summary for a small business owner. Given the P&L data, balance sheet, and anomaly report, write a clear, jargon-free narrative that:
1. Summarizes the month's financial performance in 2-3 sentences
2. Highlights the most significant changes from the prior month
3. Identifies the top 3 expense categories and any concerning trends
4. Notes any anomalies that require attention
5. Provides one actionable recommendation for improving financial health
6. Estimates cash runway in months based on current burn rate

Write in a professional but conversational tone. Use specific numbers. No hedging language ("it appears that" or "seems to suggest"). Be direct.

6. Module 5 — OpenAI “Create a Chat Completion” (Cash Flow Forecast):

System message:

You are a financial analyst. Given 3 months of P&L data, project the next 30 days of cash flow. Consider:
- Revenue trend (growing, stable, declining)
- Recurring expenses vs. one-time expenses
- Any large upcoming payments mentioned in the anomaly report
- Seasonal patterns if apparent from the data

Provide:
- Projected revenue range for next 30 days
- Projected expense range
- Projected net cash position
- Risk factors that could impact the projection
- Confidence level (high/medium/low)

7. Module 6 — Google Docs “Create Document”: Assemble all components into the report template
8. Module 7 — Gmail “Send Email”: Email the report to the client with subject line: “Your [Month] Financial Report — [Client Name]”
9. Module 8 — Notion “Create Page”: Post a summary to the client’s Notion dashboard
10. Module 9 — Slack “Create Message”: Post a brief summary to the client’s Slack channel (if applicable)

Sub-step 5c: Client Dashboard in Notion

Create a Notion page for each client with these sections:

• Current Month Status: Categorized %, Reconciled %, Open Anomalies
• Financial Snapshot: Revenue MTD, Expenses MTD, Net Profit MTD, Cash Balance
• Recent Reports: Links to the last 3 monthly reports
• Action Items: Anomalies requiring client attention with status tracking
• Trend Charts: Simple tables showing 6-month trends for revenue, expenses, and profit margin

Share this Notion page with the client. Update it automatically via Make.com. Clients who can see their financial status in real time are 4x less likely to churn than clients who only hear from you once a month.

Step 5 Check-In

1. Monthly report template is created with all 7 sections
2. Monthly close Make.com scenario generates and delivers a test report
3. AI narrative summary is specific, uses real numbers, and provides actionable recommendations
4. Cash flow forecast includes a confidence level and risk factors
5. Client Notion dashboard is created and shared
6. Test report is emailed successfully and appears in Notion

Pricing and Cost Breakdown

Service Tiers

Cost Breakdown

Total monthly cost at 1 client (Growth tier): ~$57/mo Total monthly revenue at 1 client (Growth tier): $600/mo + $1,000 setup Total monthly cost at 5 clients: ~$120/mo Total monthly revenue at 5 clients: $3,000/mo + setup fees

Production Checklist

Before activating the bookkeeping automation for any client, verify every item:

• QuickBooks/Xero connection is active and pulling transactions correctly
• Chart of Accounts reference sheet has 20+ accounts with descriptions
• AI categorization workflow processes test transactions with 85%+ accuracy
• “Review Needed” transactions are flagged and routed to the review queue
• Human review step is included for all transactions in the first month
• Bank reconciliation workflow runs weekly and matches transactions correctly
• Reconciliation exceptions are logged and a Slack summary is generated
• Anomaly detection rules are configured for the client’s business type
• High-severity anomalies trigger client notifications
• Monthly close workflow generates a complete report with narrative summary
• Cash flow forecast includes confidence level and risk factors
• Client Notion dashboard is created and shared
• Error handling (Break + Slack notification) is attached to every API module
• Automatic retry (3 attempts, 30-second interval) is enabled on all API modules
• Client has been trained on how to read their dashboard and what to do with anomaly alerts
• Vendor mapping database has at least 50 common vendor-to-category mappings