QuickBooks Desktop integration so easy we’ll build it for free.

We’ve worked with QuickBooks Desktop for 16 years, from Pro and Premier to Enterprise. Tell us what your app needs and we’ll build the integration on QuBe Sync in a free account, then send you a walkthrough-video from the expert who built it, with what to do next.

Tell us about your integration Watch an example first
Example walkthrough
Example: the walkthrough we recorded for a prospect’s QuickBooks Desktop integration, with their company’s name bleeped. Recorded by the person who built it.

Three steps, and two of them are ours.

You tell us what the integration should do. We build it against our JSON API, test it against QuickBooks Desktop’s awkward moments, and show you around it.

  1. 1 You

    Tell us about your integration

    Say where you’re starting: a QuickBooks Desktop integration, a QuickBooks Online one, or nothing yet. If you have one, your coding agent can describe it for you.

  2. 2 Us

    We build it in your free account

    The workflows for everything your app sends and reads, a simulated QuickBooks to test them against, and the setup link your customers will use.

  3. 3 Us

    We send you a walkthrough

    An email with a video of one of us explaining your integration: what we built, how we tested it, and what to do next.

Why not code it from scratch?

You can, and we have. A coding agent might even get a request through the Web Connector in an afternoon. The hard part (beyond SOAP & qbXML) is everything after; QuickBooks Desktop runs on your customer’s PC, on its own schedule, and you discover its numerous edge cases / failures one at a time on live customer accounts.

16 years of QuickBooks Desktop integration work

Since 2010, we’ve learned to prevent what we can, fix what we can, and tell the right person about the rest. Your QuBe Sync integration does all of it.

See more failure examples we handle

Where a quick integration breaks (part 1 / 347)

  1. The answer is lost mid-request

    Written from scratch

    Your code retries, and the payment is created twice.

    On QuBe Sync

    Mutations are pre-fingerprinted and automatically reconciled before sending again. Nothing is created twice.

  2. Another company file is open

    Written from scratch

    Your customer opens a different company, and your app writes their invoices into it.

    On QuBe Sync

    Each connection remembers its company file. Nothing is sent to another one, and your customer is told to open the right file.

  3. QB business rule violations

    Written from scratch

    QuickBooks refuses with a cryptic `list object "000854-6124299"` error, and the record never syncs.

    On QuBe Sync

    The workflow pauses, runs diagnostic queries, gives your app options, and carries on with the answer.

  4. Characters QuickBooks can't handle

    Written from scratch

    One curly quote from your app, and QuickBooks rejects the whole request as bad XML.

    On QuBe Sync

    Replaced with encoded equivalents QuickBooks accepts, and decoded on the way back out.

  5. QuickBooks is in multi-user mode at setup

    Written from scratch

    The Web Connector can't be authorized, and your customer emails you a QuickBooks error.

    On QuBe Sync

    The setup page has them switch to single-user, as Admin, before the Web Connector asks.

Your agent can still help: point it at our MCP server and docs, and it writes against a JSON API that already handles these.

Where are you starting from?

Tell us about what you've already built and what you need so we can take the load off your plate.

We have a QuickBooks Desktop integration Move it onto QuBe Sync. We rebuild it better than ever on our JSON API, and you delete a ton of QBD cruft from your codebase. Start from Desktop We have a QuickBooks Online integration Translate it for Desktop. Your coding agent describes it in enough detail for us to build the Desktop equivalent. Start from Online Neither, yet Start fresh. Tell us what your app should send to QuickBooks and read from it, and we’ll build a first version. Start fresh

It’s waiting in your account when the email arrives.

Everything we build lives in your QuBe Sync account, ready to run against a test QuickBooks. You change it, extend it, or call it from your app like anything you built yourself.

Your account Example

Workflows we built for you

Push records (upsert each) push_records
Ready to test
Add a transaction add_transaction
Ready to test
Record a payment against an invoice record_payment
Ready to test
Pull records and changes pull_changes
Ready to test
Simulated QuickBooks Desktop Beta A test connection to run the workflows against
Ready to test
Webhooks to your app https://app.example.com/webhooks/qube
Needs your URL

What you send, and what comes back

Use a robust JSON API to talk to QuickBooks Desktop, and receive your answers via webhook. No deciphering SOAP or qbXML, and clear messages for both you and your users when QuickBooks has an issue that needs human eyes.

Your app sends: GET /api/v2/connections/:id/customers with no paging parameters, so QuickBooks answers 100 customers at a time.
  1. QuBe Sync calls your webhook with page 1, its 100 customers in response_json.data: 
    {
  "id": "01a0e05d-8fdc-7531-9bcf-dbd53e26500c",
  "state": "response_received",
  "page": 1,
  "page_request_id": "01a0e05d-8fdc-7531-9bcf-dbd53e26500c",
  "iteration_state": "continue"
}
  2. QuBe Sync calls your webhook with page 2, its 100 customers in response_json.data: 
    {
  "id": "01a0e05d-8fdc-7531-9bcf-dbd53e26500c",
  "state": "response_received",
  "page": 2,
  "page_request_id": "01a0e05d-8fdc-7531-9bcf-dbd53e265002",
  "iteration_state": "continue"
}
  3. QuBe Sync calls your webhook with page 3, its 48 customers in response_json.data: 
    {
  "id": "01a0e05d-8fdc-7531-9bcf-dbd53e26500c",
  "state": "response_received",
  "page": 3,
  "page_request_id": "01a0e05d-8fdc-7531-9bcf-dbd53e265003",
  "iteration_state": "done"
}

The last page says done, and your app has all 248 customers.

Test against a QuickBooks simulator that fails on demand Beta

Handling failures and edge cases is the name of the game. Use a simulated QuickBooks connection to make sure you're gracefully handling errors before your customers find them for you.

  • Fail on purpose: another company file open, QuickBooks closed, a name in use, an answer lost
  • Realistic customers, vendors, items and accounts to test against
  • Never billed. Drive it from the dashboard, the API or the CLI
How the simulator works
Faults Simulated connection
connection_error Intuit's Web Connector can fail in multiple ways. Test them here first.
company_file_mismatch company_file_missing modal_dialog qb_closed unexpected
next_status Choose between various QB error codes to make sure you handle them.
3100 name in use · once
next_lost_response Test what happens when QuickBooks' response times out.
true once
latency_ms How long QuickBooks thinks before each answer.
1500 ms

With connection_error set to company_file_mismatch, your app's ReceivePaymentAddRq isn't sent to the other file: it stays retryable, and your customer reads: The Web Connector was run with a different company file than the one originally configured. To prevent conflating data between different company files, syncing has been paused. Please make sure the correct company file is open and try again. Once the right company file is open, the next Web Connector run answers the same request.

Run Web Connector now Queue test request

One link, and your customer is connected

We walk them through the Web Connector setup one step at a time and prevent the usual mistakes, even starting on the wrong computer: a Mac gets a code to open the same page on the QuickBooks PC.

Add a Connect QuickBooks button
  1. Your app, on their Mac my-app.com/settings Your customer clicks Connect QuickBooks Desktop, and you send them to their onboarding link.
  2. qubesync.com, on their Mac qubesync.com/onboarding/t_8f2c1d… A Mac can't run the Web Connector, so the page says: Open this on the QuickBooks computer. On that computer, go to qubesync.com/go and enter this code: K7P4-QMXR. Good for 15 minutes. Works once.
  3. qubesync.com, on the QuickBooks PC qubesync.com/go The code opens the same page there, and the Mac's page says it was opened on another computer. Setup goes on one step at a time: Get QuickBooks ready Add My App to the Web Connector Enter the password
  4. Your app my-app.com/webhooks/qube · connection.connected QuBe Sync's signed webhook says they're connected after their first check-in, and your app shows QuickBooks ready to go.

Multi-step jobs, run on our side

Real jobs rarely fit in one QuickBooks request. Creating an invoice means making sure the customer exists, handling a vendor that already has that name, making sure every item exists, and only then adding it. If the connection drops halfway, someone has to work out what was written and what wasn’t. We do all of that, so nobody ends up double-invoicing their customers.

Start from a tested template
  • add_transaction
  • ensure
  • resolve
  • upsert
  • pull_changes
upsert, a shipped template: makes a list record exist with the fields your app holds Next step Status 3100
The upsert chart: start, then resolve; found or picked goes to update, then updated, or name_taken on status 3100; the app stopping goes to cancelled; not found goes to create, then created, or back to resolve on status 3100. start resolve ListID, then name update list.update cancelled create kind.create updated name_taken created found or picked app stops not found 3100: name in use 3100: look again

See every path. Each workflow is a chart you can read, test-run and change, including the retry when someone takes a name mid-run.

Decide what only you can. When a name is taken, the workflow asks your app and carries on with the answer.

We handle the hard parts

QuickBooks Desktop runs on your customer’s PC, on its own schedule, and plenty can go wrong between your app and theirs. In 16 years of QuickBooks Desktop work we’ve learned to prevent what we can, fix what we can, and tell the right person about the rest.

Read how errors are handled
Failure modes: what QuBe Sync sees, what it does, and who hears about it
What goes wrong Signal What QuBe Sync does Who hears about it Mode
A field QuickBooks would reject schema check Rejected when you queue it, not minutes later on your customer’s PC Who hears about it: You, in the API response prevent
Characters QuickBooks can't handle invalid text Smart quotes, bullets, dashes and many more are replaced with encoded equivalents QuickBooks accepts. Decoded on the way back out. Who hears about it: Nobody needs to prevent
Duplicate transaction requests ExternalGUID Workflows fingerprint the transaction before creating it, so we can automatically reconcile before sending again. Who hears about it: Nobody needs to prevent
QuickBooks is in multi-user mode at setup setup check The setup page has them switch to single-user, as Admin, before the Web Connector asks Who hears about it: Your customer, on the setup page prevent
Another company file is open company_file_mismatch Nothing is sent to it. The request stays queued until the connection's own company file is open Who hears about it: Your customer: “make sure the correct company file is open” prevent
QuickBooks is closed quickbooks_connection_error Stays queued and retried until QuickBooks is opened; the Web Connector is backed off so it doesn’t hammer a closed QuickBooks Who hears about it: Your customer, once, in words they can act on resolve
A dialog is open in QuickBooks quickbooks_connection_error Retried for as long as it takes. Your customer still receives instructions so they can resolve it faster. Who hears about it: Your customer: “please close all dialogs and try again” resolve
The session ends early session closed A request QuickBooks never saw goes back in the queue Who hears about it: Nobody needs to resolve
The answer is lost mid-request timed_out The workflow checks QuickBooks before sending again. Nothing is created twice Who hears about it: Nobody needs to resolve
Someone changed the record mid-update fields overlap Your update goes through if their change doesn’t touch your fields; if it does, the workflow asks Who hears about it: Your app, only when they overlap escalate
QB business rule violations cryptic QB error The workflow pauses, runs diagnostic queries, gives your app resolution options, and carries on with the answer Who hears about it: Your app, with the context to decide escalate
Your webhook endpoint is down no 2xx Delivery retried with backoff, up to 12 attempts Who hears about it: Your team, by email if it can’t be delivered resolve
Your customer stops connecting no check-ins We send you a webhook with `connection.stalled`, and `connection.resumed` when it's back. Who hears about it: Your app escalate

And many more. Each new version of QuickBooks, qbXML and the Web Connector brings new challenges, and they are handled for you too.

Instant fuzzy search prevents duplicate items, customers and employees.

QuickBooks is notorious for duplicate name issues, and finding them is near impossible with its native query filters. On realtime connections, cached fuzzy search finds near matches in milliseconds, and lets your customers solve problems before they start.

Word order
Smith, John finds John Smith
Punctuation
ACME, Inc. finds Acme Inc
Numbered locations
Subway Store 1234 finds Subway #1234
Company suffixes
Northwind Builders LLC finds Northwind Builders
Typos
Jonh Smith finds John Smith
How matching works

Audit everything that happened

Every run keeps its trail: what it changed in QuickBooks, each step, and its event log. When a connection drops mid-request, you see how the run made sure nothing was created twice.

  1. Add a transaction sends invoice.create for invoice 1044.
  2. The connection drops before QuickBooks answers, so the add may or may not be in QuickBooks.
  3. Instead of sending it again, the run checks: looking for reference number "1044" with invoice.query, which answers whole.
  4. Of 1 candidate with reference number "1044", one carries the guid sent (txn_id 2-1791772885), so the add was applied.
  5. It reads that invoice and ends Completed: Invoice Ref 1044, TxnID 2-1791772885, created once and confirmed after a lost answer.

Build it free, launch when you’re ready

One account. Each connection runs at the speed you pick, and you pay only for the ones your customers use.

While you build

$0

Build and test in your sandbox app, against your own copy of QuickBooks or a simulated one.

After you launch

Pay per active connection, per month. Choose a speed for each one.

Standard

$25 per connection, per month

Web Connector check-in
every 5 min
Cached fuzzy search
Not included
Workflows
Not included
Made for
Syncing in the background

Realtime

$50 per connection, per month

Web Connector check-in
every 10 s
Cached fuzzy search
Included
Workflows
Included
Made for
Interactive UIs

High volume or special requirements? Talk to us

Mix and match standard/realtime connections as needed.

A connection is active when its Web Connector has checked in during the past week. Sandbox and simulated connections are never billed.

Extend it with your coding agent

We can build the first version. What it does next is yours to change, with or without us: point Claude Code, Cursor or any MCP client at qubesync.com/mcp, and it finds the right template, checks every request it writes and audits the result, without ever holding a secret.

Set up the MCP server
261 tools
Each checks its parameters and returns the v2 request to send
Workflows
Tested templates, and a validator for the charts it writes
Audit
A skill checks your integration against our 53 integration rules before each change ships
No secrets
The tools never send anything. Your code does, with your key
my-app no changes
  • Changed files show up here.
Files appear here as Claude writes them.
claude mcp add --transport http qubesync https://qubesync.com/mcp

A scripted replay: the tool results are real answers from qubesync.com/mcp; the pacing is not.

Rather build it yourself?

The JSON API, the docs and the MCP server are open to every free account.

Start building free Read the docs

Tell us what your app needs from QuickBooks Desktop. We’ll build the first version.

Tell us about your integration

Built on 16 years of QuickBooks integration work. Questions first? Write to support@qubesync.com and a real human will answer.