Tool reference

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 190 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 and several company files. 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 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 coding rules over what is new. Lines already imported are recognised, not doubled
`qb_feed_lines`	The queue, oldest first — or only what needs coding, 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 a paid add-on and the one part of this product that needs an account and a network. The direction is the point: transactions come in, and nothing about the company file goes out — the relay 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_relay_signin`	Signs this workstation in to the feed. Shared by every workstation on the same journal
`qb_connect_bank`	Returns a link for you to open in a browser. 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. Selection 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

Firm workspace (optional)

For a practice on Zeno for Firms. A workstation enrols once per journal with a code from the console’s Clients page; every company file registered here then counts as a client book on the firm’s subscription, the whole Desktop surface is entitled, and no licence key is needed on the PC. What the firm learns is the company names and what its subscription allows. The books stay on the workstation. See plans.

Tool	What it does
`qb_connect_firm`	Enrols this workstation with a code from the console, registers the local companies as client books, and refreshes the entitlement. With no code, refreshes and retries
`qb_firm_status`	The firm, what its subscription allows here, when that was last confirmed, and which companies are registered. Reads nothing over the network
`qb_disconnect_firm`	Takes the workstation out of the firm. The journal, rules, and history stay

Rules

Tool	What it does
`qb_list_rules`	Coding 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.

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, 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 — 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. 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.

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, 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.

Start here

The firm workspace

Run locally with QuickBooks Desktop

Do the work

Review, memory, and record

Reference

Tool reference

Setup

Batch

Importing a file

Audit and reversal

Bank feed

Bank connection (optional)

Firm workspace (optional)

Rules

Knowledge

Playbooks

Recurring work

Work log

Asking questions

Reading

Single postings

Money going out

Money coming in

Documents that post nothing

Inventory and receiving

Everything else

Creating list entries

Correcting list entries

Correcting transactions

Updating

Getting help

Resources

Read-only mode

​Setup

​Batch

​Importing a file

​Audit and reversal

​Bank feed

​Bank connection (optional)

​Firm workspace (optional)

​Rules

​Knowledge

​Playbooks

​Recurring work

​Work log

​Asking questions

​Reading

​Single postings

​Money going out

​Money coming in

​Documents that post nothing

​Inventory and receiving

​Everything else

​Creating list entries

​Correcting list entries

​Correcting transactions

​Updating

​Getting help

​Resources

​Read-only mode

Setup

Batch

Importing a file

Audit and reversal

Bank feed

Bank connection (optional)

Firm workspace (optional)

Rules

Knowledge

Playbooks

Recurring work

Work log

Asking questions

Reading

Single postings

Money going out

Money coming in

Documents that post nothing

Inventory and receiving

Everything else

Creating list entries

Correcting list entries

Correcting transactions

Updating

Getting help

Resources

Read-only mode