> ## Documentation Index
> Fetch the complete documentation index at: https://zenofirm.com/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# QuickBooks Desktop tool reference
> MCP tools for local integrations: reading, planning, posting, and investigating company-file work.
This reference is for people configuring AI clients or building integrations.
For day-to-day bookkeeping, start with the [Desktop edition guides](/docs/quickbooks-desktop).
You can describe the job to your assistant without typing these tool names.
The agent picks these itself. Read this when you want to know what's available, or to name a specific tool in a request.
Every tool answers with either a result or a reason it didn't work. The reason carries QuickBooks' own status message where there is one.
There are 186 of them, in the groups below.
## Setup
| Tool | What it does |
| - | - |
| `qb_setup` | The steps for setting up a new workstation. Start here |
| `qb_onboarding_status` | Saved setup progress and the next action for one or every company |
| `qb_setup_company` | Verifies permission and optionally builds the first mirror |
| `qb_complete_company_setup` | Marks the harmless end-to-end test complete |
| `qb_skip_company_setup` | Skips a company for now and saves the reason |
| `qb_help` | Suggests useful next work from setup, mirrors, plans, rules, notes, and playbooks |
| `qb_doctor` | Checks the whole chain — SDK, QuickBooks, permission, licence, journal, mirror, chat app — and leads with the first broken link |
| `qb_discover_companies` | Finds the company files on this machine. Needs no QuickBooks session |
| `qb_register_open_company` | Registers whatever QuickBooks has open, with its real name and path |
| `qb_register_company` | Registers a file by name and path |
| `qb_list_companies` | What this workstation knows about |
| `qb_forget_company` | Removes a name. Touches nothing else |
See [setting up company files](/docs/quickbooks-desktop/setup-companies) and [several company files](/docs/quickbooks-desktop/companies).
When something isn't working, `qb_doctor` is the one to reach for. It replaces the whole is-it-plugged-in conversation, opens at most one QuickBooks session, and changes nothing.
## Batch
The main workflow. Anything arriving in volume belongs here.
| Tool | What it does |
| - | - |
| `qb_plan_batch` | Validates postings against the company file and returns an approval table. Writes nothing |
| `qb_plan_cleanup` | Turns a bulk void, delete or modify — an account to clear, a date range, a list of TxnIDs, a recode rule — into the same approval table and one run. List entries to delete (the typo vendors, the unused terms) ride the same plan. Writes nothing |
| `qb_plan_names` | Turns a list of names to add — a chart of accounts, classes, customers and jobs, vendors, items, terms, and every other list with an Add — into the same approval table and one run. Checks each against the file and the other rows, warns near-duplicates by name, orders parents first. Writes nothing |
| `qb_list_plans` | Every plan, its stage, and whose move it is — across all clients, without opening a company file |
| `qb_review_batch` | Re-reads a plan, optionally filtered to blocked or warned entries |
| `qb_exclude_line` | Takes one line out of a plan before approval, or puts it back — a posting, a name a names plan would create, or a cleanup row. Changing a line after approval means approving again. Writes nothing |
| `qb_create_names` | Creates the vendors and customers a plan is blocked on, then re-plans it |
| `qb_approve_plan` | Records that you approved a batch — who, when, and in your own words. Posts nothing |
| `qb_await_verdict` | Waits for your decision on a plan, so an approval given on the review screen reaches the chat without you going back to say so |
| `qb_reject_plan` | Records that you turned a batch down, and why. The plan shows as rejected and cannot be applied |
| `qb_apply_batch` | Posts an approved plan and returns the run id that undoes it |
## Importing a file
A spreadsheet export or an IIF file from another system becomes a plan, reviewed and approved like any other batch. The server reads every row itself, so nothing is retyped and nothing is skipped quietly: a row it cannot read comes back as a warning.
| Tool | What it does |
| - | - |
| `qb_inspect_import` | Looks at a file before anything is read from it: its format, and for a CSV its headers, a few sample rows, and which columns read as dates and amounts. Says when a date like 03/04 or an amount like 1,234 could be read two ways. Touches nothing in QuickBooks |
| `qb_import_table` | Turns a CSV and a column map — which column is the date, the amount, the payee, the account — into a plan to review and approve. Rows that make one document, like a bill over several lines, can be grouped into one. Writes nothing until the plan is applied, and the run can be reversed |
| `qb_import_iif` | Turns a QuickBooks IIF file into plans to review and approve — new names first, then the transactions against them. Never goes through QuickBooks' own IIF import, which posts everything unreviewed. Reversible |
The column map is part of what the reviewer reads, so a column read as the wrong thing is caught before anything posts. The Desktop edition adds one field to it, `bankAccount`: the column naming the account the money moved through — the bank on a check, the card on a charge, the bank a deposit lands in, the account a transfer comes from. QuickBooks Desktop records that account on the transaction itself, and without it every check, charge, deposit and transfer in the file would be held back. When every row uses the same bank or card, give it once instead of pointing at a column.
Dates and amounts are read the way the file itself settles them. When it can't — every date could be day-first or month-first, every amount could be 1,234 or 1.234 — the import stops and names the column rather than guessing; pass `dateOrder` (`DMY` or `MDY`) or `decimalMark` (`.` or `,`) to say which. `qb_inspect_import` tells you in advance which columns need it.
A workbook is refused; save the sheet as CSV first. Bank downloads (`.qfx`, `.ofx`, `.qbo`) go through the [bank feed](#bank-feed) instead.
## Audit and reversal
| Tool | What it does |
| - | - |
| `qb_status` | Licence state, read-only mode, journal location, machine id |
| `qb_list_runs` | Every batch posted from this install |
| `qb_run_detail` | One run's entries and their outcomes |
| `qb_explain_transaction` | Which batch posted a transaction, who approved it, and its source document |
| `qb_reverse_run` | Voids everything a run posted |
## Bank feed
The statement file you already download from the bank — `.qfx`, `.ofx`, `.qbo` or CSV — worked as a queue. Nothing here connects to a bank and nothing leaves the workstation: the transport is the file, and everything after it is the ordinary plan → approve → apply loop.
| Tool | What it does |
| - | - |
| `qb_setup_feed_account` | Registers a bank or card account and names the QuickBooks account its lines post to — a Bank account for a bank, a Credit Card account for a card, checked against the chart. Moving an account that already posts somewhere needs `confirmMove`, because every line not yet posted moves with it |
| `qb_feed_accounts` | The accounts statements are imported for, and how many lines sit in each state |
| `qb_set_feed_account` | Pauses or resumes a feed account. Pausing stops new lines arriving without forgetting where the account posts or dropping what is already staged; resuming fills the gap in |
| `qb_name_cards` | Names the cards on a card account by their last four digits — the second Amex, the office manager's Visa — and gives each a default account, suggested on that card's uncoded charges when no rule says otherwise |
| `qb_cardholders` | Which cards are on each card account, who holds them, each card's default account, and how many of its lines are still open. Read-only |
| `qb_preview_statement` | Reads a file and reports which column was read as what. Stages nothing |
| `qb_import_statement` | Stages a statement and runs your rules over what is new. Lines already imported are recognised, not doubled |
| `qb_feed_lines` | The queue, oldest first — or only what needs a category, what a rule suggested, what is ready to plan, or what is matched. Narrows by date, by text, or to one card by its last four or its name |
| `qb_match_feed` | Finds transactions already in the company file that a staged line might be, and lines on two fed accounts that are one transfer |
| `qb_match_options` | Everything that could be one line when no single match is: several transactions that add up to it, the other half of a transfer, and a search of the register for the check that cleared late or was entered for the wrong amount. Writes nothing |
| `qb_accept_feed_match` | Records that a line is something already posted. Takes it out of the queue without posting |
| `qb_code_feed_lines` | Records the account, payee and class for staged lines — or excludes a line, puts one back, or links it to what is already in the file, one transaction or several. Writes nothing to QuickBooks |
| `qb_exclude_feed_line` | Takes a line out of the queue without posting it, and remembers that you did |
| `qb_plan_feed` | Turns the coded lines into an approval table, exactly like `qb_plan_batch`. The two halves of a transfer become one entry, a line whose amount is already in the register is held back to be matched rather than posted twice, and uncoded lines can be swept to a holding account |
## Bank connection (optional)
A live bank feed, which is the [Desktop connectors add-on](/docs/quickbooks-desktop/bank-feed#a-live-bank-connection) and the one part of this product that needs a Zeno account and a network. The computer is linked to Zeno from the console's **Bank feed** tab, not from the chat. The direction is the point: transactions come **in**, and nothing about the company file goes out. Zeno never learns a chart of accounts, a vendor name, how a line was coded, or which client it belongs to. It holds your bank connection, not your bank history, and forgets each transaction as soon as the workstation says it staged it. Once a line arrives it is indistinguishable from one off a downloaded statement.
| Tool | What it does |
| - | - |
| `qb_connect_bank` | Returns a link for you to open in a browser. Needs the computer linked to Zeno from the console first, and says so if it is not. Your banking credentials never reach this machine. `syncFromDate` says where the feed starts and how far back the bank is asked to go, up to two years, settled once when the login is connected |
| `qb_bank_balance` | The bank's balance beside the QuickBooks balance for each fed account, with the difference explained: lines not yet in QuickBooks, and what the feed cannot account for |
| `qb_bank_connections` | Your bank logins, the accounts on each, and which are syncing. Says when a login has lapsed, and where each feed starts |
| `qb_select_bank_accounts` | Chooses which accounts sync, and where each one's lines post. Needs the computer linked to Zeno from the console. A selected account is what is billed. Each must go to a Bank or Credit Card account of the right kind, and moving one already bound needs `confirmMove` |
| `qb_set_feed_start` | Moves where a login's feed starts. Earlier re-reads the bank's history on the next sync without doubling what is already staged; later only narrows |
| `qb_sync_bank_feed` | Collects what the bank has sent into the same queue a statement import fills |
| `qb_disconnect_bank` | Disconnects a login and stops paying for it. Lines already staged are left alone |
## Rules
| Tool | What it does |
| - | - |
| `qb_list_rules` | Rules saved for a company file |
| `qb_learn_rule` | Saves a coding decision so it applies next time. Matches on the payee, memo, reference, amount range or direction, and can code the lines already waiting too |
| `qb_test_rule` | Tries a rule before it is saved: which waiting bank lines it would catch, and how many of the last two years' transactions it would have matched. Saves nothing |
| `qb_forget_rule` | Removes a rule. Changes nothing already posted |
| `qb_suggest_coding` | Proposes coding for a descriptor from the rule that matches it, or, with no rule, from how the file has coded that payee before. Saves nothing |
## Knowledge
Notes about a client's books that a rule can't express. Entries land as drafts and surface on their own once confirmed — see [what it remembers](/docs/quickbooks-desktop/memory#knowledge).
| Tool | What it does |
| - | - |
| `qb_write_knowledge` | Records a note, anchored to the vendors and customers it's about |
| `qb_list_knowledge` | What's recorded for a company, drafts included |
| `qb_confirm_knowledge` | Confirms an entry, which is what makes it start surfacing |
| `qb_forget_knowledge` | Removes an entry |
| `qb_study_history` | Reads a client's past two years — how each vendor is coded and how often it bills, whether classes are really used, which accounts have gone quiet — into draft notes and rule proposals for you to confirm, plus the questions worth asking first |
`qb_study_history` is for a new client once their history has been copied to the workstation, and again after a cleanup. Everything it finds lands as a draft; the rules it proposes are only saved when someone accepts them with `qb_learn_rule`.
## Playbooks
| Tool | What it does |
| - | - |
| `qb_write_playbook` | Writes down a procedure, with `{{named}}` slots filled in at run time |
| `qb_list_playbooks` | Procedures for a company, plus those that apply to every client and the checks built into Zeno |
| `qb_run_playbook` | Returns the steps with values filled in. Changes nothing itself. Also runs a built-in check, or `check-up` for all of them |
| `qb_confirm_playbook` | Confirms a draft. Only confirmed playbooks can be run |
| `qb_forget_playbook` | Removes a playbook |
The built-in checks read the books themselves — balances and agings live from QuickBooks, coding and names from the local copy — and come back as a list of things to raise: balances on the wrong side of their account, Undeposited Funds or a merchant clearing account that never washed to zero, invoices and bills open past 90 days, lines sitting in Uncategorized or Ask My Accountant, large purchases expensed outright, and the same vendor under two spellings. Anything the ledger needs is proposed as a plan. A check writes nothing to the company file. Run the check-up on a client's first connection, before asking them anything.
## Recurring work
The standing jobs a practice does for each client — the monthly close, quarterly sales tax — kept on a calendar, and shown on the console's Today page until someone closes them. Each engagement opens a period every cycle and falls due a set number of days after it ends. Bind a confirmed playbook or a built-in check to it and an agent can prepare each period's work; a person still approves what it prepared, and a person closes the period.
| Tool | What it does |
| - | - |
| `qb_create_engagement` | Sets up recurring work for a client, with how often it comes round and when each period is due. Writes only Zeno's own calendar, never the company file |
| `qb_list_engagements` | Every client's recurring work, the playbook each is bound to, and the workstations that have asked for due work and when each last did |
| `qb_bind_playbook` | Attaches a confirmed playbook or a built-in check to an engagement, so an agent can work each period. Refuses a draft |
| `qb_retire_engagement` | Ends an engagement. No new periods open; any still open stay until closed |
| `qb_due_work` | What recurring work is due now, across every client, with each period's procedure. Claims nothing |
| `qb_start_scheduled_work` | Claims one due period and returns the procedure to follow. The claim holds for two hours, so two workstations on one journal cannot prepare the same batch. Posts nothing |
| `qb_finish_scheduled_work` | Records what a scheduled run prepared — plans made, nothing to do, or blocked and why — and writes the work log. Never closes the period |
| `qb_close_period` | Marks a period done, skipped, or open again. Done also locks its dates against new plans, postings, corrections and reversals |
| `qb_park_period` | Takes a period off Today until a date — waiting on a statement, a client, a signature. Does not close it or lock anything |
Nothing runs in the background on a workstation. A period falls due at the first session on or after its due date, so one due on a Saturday is first offered on Monday, as overdue.
Closing a period as done is Zeno's own lock, not QuickBooks' closing date, which it never touches. Afterwards Zeno refuses anything dated inside the period: a line of a new plan, a single posting, a correction, void or delete of a transaction in it (or moving one into it), and reversing a run with any row in it. Each refusal names the period that stopped it. A plan built before the period closed isn't rechecked until it is planned again, and list changes and time, mileage and build corrections aren't covered. The lock takes effect at once for whoever plans next, so the agent names it and waits for your yes. `qb_close_period` with status `open` lifts it.
## Work log
| Tool | What it does |
| - | - |
| `qb_log_work` | Records what was done this session and why |
| `qb_work_log` | Reads entries back, by company and period |
## Asking questions
`qb_report` runs against the open company file. The rest run against a [local copy](/docs/quickbooks-desktop/questions), never against QuickBooks.
| Tool | What it does |
| - | - |
| `qb_report` | Runs a QuickBooks report — P\&L, balance sheet, trial balance, agings. Call with no report type for the catalogue |
| `qb_sync_mirror` | Copies the company file into the local database, and says how many transactions are dated before the range it holds |
| `qb_query` | Runs a SQL SELECT against that copy. Read-only, capped at 500 rows |
| `qb_mirror_status` | What the copy holds and how old it is, including where its transactions begin and how many older ones the company file has — payroll aside, which isn't counted |
## Reading
Direct from QuickBooks, in fixed shapes, returned as CSV.
| Tool | What it does |
| - | - |
| `qb_company_info` | The open company file |
| `qb_list_accounts` | Chart of accounts |
| `qb_find_customers` | Customers and jobs |
| `qb_find_vendors` | Vendors |
| `qb_list_classes` | Classes |
| `qb_list_items` | Items |
| `qb_list_employees` | Employees, inactive included, with status and hire dates. Never social security numbers, pay, or contact details |
| `qb_list_budgets` | The budgets set up for a fiscal year, with each row's annual figure. Budgets are still written in QuickBooks itself |
| `qb_stock_by_site` | Quantity on hand per item per inventory site. Needs Advanced Inventory |
| `qb_open_invoices` | Unpaid invoices |
| `qb_bills_to_pay` | What one vendor is owed, with the credits available against it |
| `qb_undeposited_payments` | Payments and sales receipts taken in but not yet banked |
| `qb_find_transactions` | Transactions by date, type, name, amount, or reference |
| `qb_list_reference_data` | Terms, payment methods, tax codes, reps, and the other small lists everything is coded against |
| `qb_list_custom_fields` | The custom fields this file defines, and what each applies to |
| `qb_1099_mapping` | Which accounts feed each 1099 box, and whether the file files them at all |
| `qb_sales_tax_owed` | What sales tax is owed, per agency, with the items behind each total |
| `qb_income_tax_mapping` | Which tax line each account reports under, and the P\&L accounts assigned to none |
## Single postings
For one-off work. Volume belongs in a batch, which adds preflight, the approval step, and automatic duplicate protection that these don't have.
### Money going out
| Tool | What it does |
| - | - |
| `qb_record_bill` | Records a vendor bill to be paid later |
| `qb_record_check` | Writes a check |
| `qb_record_credit_card_charge` | Records a card charge or credit |
| `qb_record_vendor_credit` | Records a credit from a vendor |
| `qb_pay_bills` | Pays open bills, applying credits and discounts |
| `qb_record_sales_tax_payment` | Pays a sales tax liability |
| `qb_set_1099_mapping` | Maps accounts onto 1099 boxes, or turns 1099 filing on |
| `qb_record_transfer` | Moves money between two accounts |
### Money coming in
| Tool | What it does |
| - | - |
| `qb_record_invoice` | Bills a customer on a document they can pay against |
| `qb_record_sales_receipt` | Records a sale paid at the time |
| `qb_record_charge` | Bills a customer in their register, to go out on a statement rather than an invoice |
| `qb_receive_payment` | Applies a customer payment to open invoices |
| `qb_record_deposit` | Banks undeposited receipts, or records a direct deposit |
| `qb_record_credit_memo` | Records a customer credit or refund |
| `qb_refund_credit_card` | Returns a customer's credit to the card it came from |
A statement charge suits anyone billing the same thing repeatedly — rent, a retainer, a storage bay. The charges accumulate and one statement covers the period. If the customer expects a document to pay against, that's an invoice.
To bank receipts already taken in, call `qb_undeposited_payments` first: it returns the line ids `qb_record_deposit` needs, and no other tool returns them.
### Documents that post nothing
| Tool | What it does |
| - | - |
| `qb_record_estimate` | Quotes a customer |
| `qb_record_sales_order` | Records an order to be invoiced later |
| `qb_record_purchase_order` | Orders goods from a vendor |
None of these three move money or change a balance. They exist to be turned into an invoice, a receipt, or a bill later.
### Inventory and receiving
| Tool | What it does |
| - | - |
| `qb_record_item_receipt` | Records goods that arrived but haven't been billed yet |
| `qb_build_assembly` | Builds an inventory assembly from its components |
| `qb_finish_build` | Finishes a build left pending, or changes how many units it made |
| `qb_record_inventory_adjustment` | Corrects quantity or value on hand |
| `qb_transfer_inventory` | Moves stock between sites. Nothing reaches the P\&L |
| `qb_modify_inventory_transfer` | Corrects a stock transfer |
An item receipt raises quantity on hand without creating anything payable — it won't appear in `qb_pay_bills`. When the vendor's invoice arrives, someone ticks *Bill Received* in QuickBooks and the same record becomes a bill.
These four, and billing a purchase order through `qb_record_bill`'s `purchaseOrderTxnIds`, are included with the [Enterprise licence](/docs/quickbooks-desktop/plans#the-inventory-domain) — and with the free evaluation. Every other tier still *reads* everything about an inventory file: valuation, quantity on hand, open purchase orders, and corrections to inventory transactions already in it.
### Everything else
| Tool | What it does |
| - | - |
| `qb_record_journal_entry` | Records a journal entry |
| `qb_record_vehicle_mileage` | Records a trip against a vehicle |
| `qb_record_time` | A time activity — who worked, how long, for which job. Billable time reaches the next invoice |
## Creating list entries
| Tool | What it does |
| - | - |
| `qb_create_customer` | Adds a customer or a job |
| `qb_create_vendor` | Adds a vendor |
| `qb_create_person` | Adds an employee, or an other name for someone the file pays |
| `qb_create_account` | Adds an account to the chart |
| `qb_create_class` | Adds a class |
| `qb_create_item` | Adds an item |
| `qb_create_item_group` | Adds a group item — several items billed as one line |
| `qb_create_item_assembly` | Adds an inventory assembly, with the bill of materials it is built from |
| `qb_create_item_fixed_asset` | Records something the firm owns in the Fixed Asset Item List. Posts nothing |
| `qb_create_calculated_item` | Adds a discount, subtotal, payment, sales tax item, or sales tax group |
| `qb_create_terms` | Adds payment terms |
| `qb_create_vehicle` | Adds a vehicle to the Vehicle List |
| `qb_create_currency` | Adds a currency to a multicurrency file |
| `qb_create_price_level` | Adds a price level — a percentage off everything, or named items priced specially |
| `qb_create_unit_of_measure` | Adds a unit-of-measure set. Cannot be corrected afterwards |
| `qb_create_inventory_site` | Adds a warehouse, yard or van. Needs Advanced Inventory |
| `qb_create_billing_rate` | Adds a billing rate level. Cannot be corrected afterwards |
| `qb_create_sales_rep` | Adds a sales rep — initials, and the person they stand for |
| `qb_create_sales_tax_code` | Adds a sales tax code — the taxable/not flag, not a rate |
| `qb_create_list_name` | Adds a customer type, job type, vendor type, payment method, shipping method, or customer message |
| `qb_create_todo` | Adds a to-do — a note with a reminder, about a customer, vendor, employee or lead |
| `qb_create_lead` | Adds a prospect to the Lead Center, with its locations and contacts. Not a customer until converted there |
| `qb_create_workers_comp_code` | Adds a workers' comp code with its rate history. Payroll files only |
| `qb_create_special_account` | Has QuickBooks create one of its own reserved accounts by role — Undeposited Funds, Opening Balance Equity, Retained Earnings and the rest |
| `qb_create_special_item` | Has QuickBooks create its finance-charge item or the two reimbursable-expense items |
A name can't be deleted from a QuickBooks file once anything has used it, only made inactive. To add a whole list at once — a new client's chart of accounts, a season's customers — use `qb_plan_names`, which reviews and applies like any batch; to create the names a posting batch is waiting on, use `qb_create_names`.
Customers, vendors, employees, and other names share one namespace, so a name taken by any of them is taken for all four, and nothing moves a name between those lists later.
`qb_create_list_name` is the one to check twice. QuickBooks has no way to rename, hide, or remove those six lists' entries from outside its own window, so a misspelling there is permanent as far as this connection is concerned.
`qb_create_calculated_item` covers the five item types that change what a form adds up to rather than describing something sold: a discount, a subtotal, a payment, a sales tax item, and a sales tax group. They're separate from `qb_create_item` because they carry no price and no cost, and the fields they do take — a discount rate, a tax rate and its agency, where a payment deposits to — mean nothing on the other item types. A percentage discount needs a subtotal item above it on the form to apply to the whole order rather than to the line immediately above. Use a sales tax group wherever two bodies tax the same sale — a state rate plus a county rate — because each member keeps its own agency and the liability report still splits the money per return, which one item at the combined rate would not. Correcting one is `qb_modify_calculated_item`, separate from `qb_modify_item` for the same reason — and note that a group's member list is replaced wholesale, so adding a jurisdiction means passing the existing ones again alongside it.
## Correcting list entries
Each of these shows what would change and waits for confirmation before it changes it. The preview works even on a read-only install.
| Tool | What it does |
| - | - |
| `qb_modify_customer` | Corrects a customer or job |
| `qb_modify_vendor` | Corrects a vendor |
| `qb_modify_person` | Corrects an employee or other name |
| `qb_modify_account` | Corrects an account |
| `qb_modify_class` | Corrects a class |
| `qb_modify_item` | Corrects an item |
| `qb_modify_item_group` | Corrects a group item |
| `qb_modify_item_assembly` | Corrects an inventory assembly, including what it is made of |
| `qb_modify_item_fixed_asset` | Corrects a fixed asset record, or marks one sold |
| `qb_modify_calculated_item` | Corrects a discount, subtotal, payment, sales tax item, or sales tax group |
| `qb_modify_time` | Corrects a time activity, keeping the entry an invoice may already link to |
| `qb_modify_vehicle` | Corrects a vehicle |
| `qb_modify_currency` | Corrects a currency |
| `qb_modify_price_level` | Corrects a price level. Sending items replaces the whole book |
| `qb_modify_inventory_site` | Corrects an inventory site |
| `qb_modify_sales_rep` | Corrects a sales rep |
| `qb_modify_sales_tax_code` | Corrects a sales tax code |
| `qb_modify_todo` | Corrects a to-do, moves its reminder, or marks it done |
| `qb_modify_lead` | Corrects a lead's name, status, company or phone |
| `qb_modify_workers_comp_code` | Corrects a workers' comp code or adds the next rate to its history |
| `qb_merge_duplicates` | Merges two duplicate accounts, classes, customers, or vendors into one |
| `qb_define_custom_field` | Defines a custom field, or changes which records it applies to |
| `qb_delete_custom_field` | Removes a custom field and every value ever stored in it |
| `qb_delete_list_entry` | Deletes a list record nothing references — the typo vendor, the duplicate class, the unused terms or tax code, a vehicle, a to-do: every kind QuickBooks can delete. Previews first, and QuickBooks refuses anything with history. Many at once is `qb_plan_cleanup` |
Renaming a name rewrites it on every transaction, report, and statement the file will ever print, and QuickBooks keeps no record of the spelling it replaced. The previous version is saved in the run journal, and nowhere else.
`qb_merge_duplicates` is the one thing here with no way back — the "Home Depot" / "HOME DEPOT" / "Home Depot #4" problem. QuickBooks provides no unmerge.
## Correcting transactions
| Tool | What it does |
| - | - |
| `qb_modify_transaction` | Corrects a transaction in place, without voiding and reposting it |
| `qb_void_transaction` | Voids a transaction, keeping it in the register |
| `qb_delete_transaction` | Deletes a transaction outright |
| `qb_set_cleared_status` | Sets the cleared flag. Not the same as reconciling |
| `qb_set_custom_field` | Writes a custom-field value onto a record or a transaction |
| `qb_close_purchase_order` | Closes a purchase order by hand, or reopens one |
| `qb_close_sales_order` | Closes a sales order by hand, or reopens one |
`qb_modify_transaction` covers bills, checks, invoices, sales receipts, journal entries, card charges and credits, deposits, customer payments, bill payments, transfers, credit memos, vendor credits, sales tax payments, inventory adjustments, purchase orders, estimates, statement charges, sales orders, item receipts, and assembly builds. Like the list corrections above, it previews first and posts only on confirmation.
Voiding preserves the audit trail and deleting doesn't. Prefer voiding unless you have a reason.
Both of those act on one transaction. Clearing many — a test account, a duplicated import, a year that was entered twice — is `qb_plan_cleanup`, which reads every target, orders deposits and payments ahead of the invoices and bills they settle, keeps a snapshot of each row in the run journal before it goes, and puts the whole list on a review page for your approval. A transfer can only be zeroed, because the QuickBooks SDK will neither void nor delete one. A cleanup run cannot be reversed: nothing un-voids a transaction, and a deleted one is re-entered from its snapshot as a new posting.
The same plan changes transactions in place. A cleanup with the action `Modify` carries a patch — a header field to set on every row (date, reference number, memo, party, account, due date, deposit account, amount), a recode rule for the lines (every line on one account, class, item or customer becomes another, and every other line is carried through untouched by its own id), or both. Each row shows exactly what would change, worked out from the transaction as it was read, and a row where nothing would change is blocked rather than approved as a no-op. Apply rebuilds the change from the transaction as it stands at that moment, refuses a row that has moved since the plan was built, stores the version replaced in the run journal first, and sends the same request `qb_modify_transaction` would. "Recode every check on Job Materials to Job Related Costs for the year" is one plan, not a hundred confirmed calls. A modified transaction keeps its TxnID and its reconciliation; putting one back is `qb_modify_transaction` with the fields under `replacedVersion`.
Neither works on funds transfers — see [what it can't do](/docs/quickbooks-desktop/limits#transfers-are-a-one-way-door).
Closing an order posts nothing. It's how you tell QuickBooks to stop offering a cancelled balance when raising the next invoice or bill, and it can be undone by closing it again the other way.
## Updating
| Tool | What it does |
| - | - |
| `qb_check_for_update` | Asks whether a newer build is published, at the moment you run it |
| `qb_download_update` | Downloads that installer and verifies its checksum. Doesn't run it |
See [updating](/docs/quickbooks-desktop/updating).
## Getting help
| Tool | What it does |
| - | - |
| `qb_contact_support` | Writes to Zeno's support inbox about Zeno itself — a bug, a missing capability, a question, licensing, or feedback |
Ask for it in the chat where you hit the problem, and the account you already
gave stays as it was written. Your build, machine id, licence state and this
install's health go with it, so nobody has to ask you for them, and you see
the whole message — including what's attached — before anything sends.
It needs an email address, because a workstation licence carries none. Nothing
is sent back to that address; it's where a reply comes to, so give one you
read, and keep your own copy of what you sent.
Nothing about your books is included. It's a report about the software.
## Resources
Alongside the tools, the server publishes reference data your client can hold onto instead of fetching per request. Clients that support MCP resources pick these up automatically; clients that don't lose nothing, because everything here is also reachable through a tool.
| Resource | What it is |
| - | - |
| `zeno-qbd://knowledge` | Everything confirmed about the open company, grouped by category |
| `zeno-qbd://accounts` | Chart of accounts |
| `zeno-qbd://vendors` | Vendors |
| `zeno-qbd://customers` | Customers and jobs |
| `zeno-qbd://classes` | Classes |
| `zeno-qbd://items` | Items |
| `zeno-qbd://mirror-status` | How fresh the local copy is |
| `zeno-qbd://runs` | Recent runs |
| `zeno-qbd://plan/{planId}` | One plan's approval table, as it was shown |
| `zeno-qbd://run/{runId}` | One run's entries and outcomes |
The five list resources come from the [local copy](/docs/quickbooks-desktop/questions), so they're as fresh as the last sync, and reading them never waits on QuickBooks.
`zeno-qbd://knowledge` carries confirmed entries only. A draft is a proposal, and a resource a client may load the moment it connects is not the place for one.
## Read-only mode
Every tool under **Single postings**, **Creating list entries**, **Correcting list entries**, and **Correcting transactions**, plus `qb_apply_batch`, `qb_create_names`, and `qb_reverse_run`, refuses when the install is read-only. Reading and planning work normally.
The corrections are the one partial case: their preview still runs, so a bookkeeper on a read-only install can see exactly what a fix would involve. Only the confirmation is refused.
With writing enabled, those tools reach a named company whether or not it is open in QuickBooks, given **always allow** permission. Which login QuickBooks records the work under is explained in [Companies](/docs/quickbooks-desktop/companies#which-name-the-audit-trail-carries).
This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.