A8gent
Build guide - QuickBooks Online

QuickBooks invoice chasing: the escalating ladder

A three-stage overdue invoice sequence built on the QuickBooks Online API: soft, firm, then a human. Stop-on-payment logic and copy for every rung.

A8gent
·

What you get from this guide

  • A three-rung ladder with real copy for each stage, not one reminder repeated
  • What the QuickBooks Online Invoice entity exposes for chasing payment
  • Webhooks vs Change Data Capture vs polling, and the latency each gives you
  • Stop-on-payment logic, and why re-checking at send time is non-negotiable
  • The point where a human has to take over - and why it is before the final notice

Chasing badly costs more than the invoice

Start with the thing the software vendors leave out. Chasing money badly damages the relationship, and for a business whose next job comes from the last customer, that damage is usually worth more than the invoice being chased.

There are three ways to get it wrong, and automation makes all three easier. You can chase an invoice that was paid last week, which tells the customer you do not know your own books. You can escalate on a schedule rather than on judgement, so a client of nine years gets the same third notice as a stranger who never intended to pay. Or you can send a firm message to somebody who simply never received the invoice, which converts an administrative problem into an argument.

The counter-argument for automating anyway is strong, and it is not about efficiency. Small businesses systematically under-chase, because chasing is awkward and there is always something more urgent. Invoices drift for six weeks not because a process failed but because nobody wanted to make the call. A well-built ladder removes the decision and keeps the wording warm, which is precisely the combination a person struggles to hold under time pressure.

So build it - carefully, with real stop conditions, and with a human at the top of the ladder. That is what this page is. Every Intuit fact below is dated August 2026 and flagged with how confidently we could verify it, because their documentation portal did not fully cooperate.

What the QuickBooks Online API gives you

A verification caveat we are not going to hide

Intuit's developer documentation at developer.intuit.com is a client-rendered application. Fetching the Invoice reference, the webhooks documentation and the Intuit developer help articles returned the application shell - feature flags and configuration - rather than the documentation text. Everything attributed to Intuit below comes from Intuit's own pages as surfaced through search of their domains in August 2026, not from a page we could render and read end to end. Treat field names and limits as accurate in shape and confirm exact semantics and the current minor version in the live docs before you build.

With that said, the shape of the API is well established and is what the build depends on. The Accounting API exposes an Invoice entity whose fields include Balance, DueDate and EmailStatus - the last of which takes documented values including NotSet, NeedToSend and EmailSent. There is a separate Payment entity, and payments link to the invoices they settle through linked-transaction references. Query is SQL-like, so filtering invoices on balance and due date is a single request rather than a fetch-everything loop.

The query at the centre of the whole build (confirm syntax in Intuit's live docs)

SELECT * FROM Invoice
 WHERE Balance > '0'
   AND DueDate < '2026-08-05'
 ORDERBY DueDate ASC

# Two fields do the work:
#   Balance  -> is anything still owed
#   DueDate  -> how far past terms we are
#
# Age band = today - DueDate. That single number
# decides which rung of the ladder applies.
# Everything else is copy and judgement.

Two design points fall out of this immediately. First, derive the age band at run time from DueDate rather than storing a stage counter somewhere. A stored counter drifts, survives a payment you did not notice, and is the usual root cause of the paid-invoice-chased bug. Second, treat QuickBooks as the source of truth for balance, always. Your automation platform holds no authoritative view of whether money arrived.

On access: Intuit issues separate development and production credentials, and its own guidance is to use the Development credentials with sandbox companies and the Production credentials only for live apps and live QuickBooks Online companies. Connection is OAuth 2.0, so refresh-token handling and a real alert on refresh failure belong in scope from the start - a silently expired connection on a receivables automation means nobody chases anybody for a month and nothing goes red.

Webhooks, CDC or polling for payment status

You have three ways to know an invoice has been paid, and the right build uses at least two of them.

Learning about payment (Intuit-documented mechanisms, August 2026)
MechanismWhat it gives youWhere it falls short
WebhooksPush notification of data-change events on subscribed entities. Intuit describes webhooks as replacing periodic pollingIntuit documents events as aggregated over a five-minute period, so it is near-real-time, not real time. Missed deliveries need a backstop
Change Data CaptureAsk for everything changed since a timestamp. Intuit documents CDC operations for exactly thisYou still have to run it on a schedule, and you have to track the timestamp reliably
Polling the querySimple, obvious, no endpoint to expose or verifyLatency equals your interval, and it burns requests. Fine at a few runs a day, wasteful hourly

The pattern we would build: webhooks to react quickly, a scheduled query as the authority, and CDC to catch up after downtime. The scheduled query is the important one, because it is the run that decides who gets chased - and because it re-reads state fresh, it is structurally incapable of chasing a paid invoice as long as you send inside the same run. The polling vs webhook entry is worth reading if this trade is new to you; unlike the lead-response builds, where webhook latency is the entire game, here a five-minute or even a six-hour lag is harmless. Nobody is upset that their payment took an hour to register. They are upset when it never did.

On volume, Intuit's published throttling figures as surfaced from its developer help material in August 2026 are 500 requests per minute per realm, 10 concurrent requests, and 40 batch requests per minute per realm, with the per-realm limit shared between apps connected to the same company. That is far more than this workflow needs. Respect rate limits anyway, and pair them with retry and backoff so a transient 429 or 500 does not skip a day of chasing in silence.

The escalating ladder, with copy

The forum answer everyone eventually finds is right about the structure and vague about the wording, so here is the wording. Three rungs. The tone moves, the facts get more specific, and the sender changes at the top.

A three-stage chase ladder (illustrative - align to your own payment terms)
StageAge past dueTone and sender
1 - Soft1 to 7 daysAssumes it was missed. Automated, from the business email
2 - Firm8 to 14 daysStates terms and asks for a payment date. Automated, from the business email
3 - Final15 days and beyondSpecific and consequential. Human-triggered, from the owner, after a phone call

Stage 1 - soft, days 1 to 7

Subject: Invoice {number} - just in case it got missed

Hi {first_name},

Quick note that invoice {number} for {amount} was due
on {due_date}. It's very likely just sitting in a pile
somewhere - happens to all of us.

You can pay it here: {payment_link}
Or reply and I'll resend the invoice.

Thanks again for the work on {job_reference}.
{sender_name}, {business}

# What this does NOT do:
# - mention terms
# - mention consequences
# - imply anything about the customer

Stage 2 - firm, days 8 to 14

Subject: Invoice {number} - {days} days past due

Hi {first_name},

Invoice {number} for {amount} is now {days} days past
its due date of {due_date}. Our terms are {terms}.

Two things would help:
1. If it's already scheduled, tell me the date and
   I'll take it off my list.
2. If something's wrong with the invoice, tell me
   what and I'll fix it today.

Pay here: {payment_link}

{sender_name}, {business}

# The shift: it asks for a DATE or a PROBLEM.
# Both answers are useful. Silence is now the
# only outcome that escalates.

Stage 3 - final, day 15+ (drafted by the automation, SENT by a human)

Subject: Invoice {number} - needs resolving this week

{first_name},

I've written twice about invoice {number} for {amount},
now {days} days past due, and haven't heard back.

I'd rather sort this directly than escalate it. Can you
call me on {phone} this week, or reply with a date
you can pay by?

If I don't hear from you by {date}, I'll have to
{stated_next_step_from_your_terms}.

{owner_name}, {business}

# Note: sent by the owner, after a phone call has
# already been attempted. The automation prepares
# this. A person decides to send it.

The design logic of the ladder is that each rung asks for something different. Stage one asks for payment. Stage two asks for a date or a problem - and a stated problem is a genuinely good outcome, because a disputed line item you did not know about is the real reason plenty of invoices sit unpaid. Stage three asks for a conversation. Nowhere does the sequence simply repeat itself in a louder voice, which is what most built-in reminder features actually do.

Between stages two and three, put in a hard pause of at least a few days. The gap is not a technical requirement, it is a courtesy that gives a busy person time to act on the last message before you decide they have ignored it. It is also the window in which the phone call belongs.

Stop-on-payment, and why it is the hard part

One rule outranks every other rule on this page: never chase a paid invoice. It is the failure that makes a business look disorganised to precisely the customer who just paid them, and it is entirely avoidable.

  • Re-query the balance in the same run as the send. Not on the schedule that queued the message - immediately before dispatch. If you queue at 6am and send at 9am, you have a three-hour window in which to be wrong.
  • Handle partial payment as a separate state. A balance that dropped but is not zero is not "still overdue" in tone terms. It is a customer who is paying you. Acknowledge the part payment or drop the invoice to a human; do not send stage two to someone who just paid you most of it.
  • Suppress disputes, plans and named accounts. A flag in QuickBooks or in your own list, read on every run. Anything flagged leaves the sequence entirely rather than skipping one message.
  • Make sends idempotent per invoice per stage. A retried workflow run must not send stage one twice. Idempotency is the concept and a stage-sent log keyed on invoice ID is the implementation.
  • Cap the sequence. Three messages and out, into a human's queue. An automation that chases forever is a machine for losing customers slowly.

Test this with the sandbox, not with customers

Build the ladder against a sandbox company with invented overdue invoices, mark one paid mid-sequence, and confirm the next message does not go. Then mark one partially paid and confirm it routes to a human. Those two tests are the ones that matter, and they are exactly the two people skip because the happy path already works.

Where a human takes over

The handover point is a business decision dressed up as a technical one, so decide it deliberately. Our position: the automation owns stages one and two, and a person owns everything after that.

By day fifteen, the automated approach has been tried twice and has not worked. Sending a third automated message in a firmer typeface is not a new strategy, it is the same strategy with worse manners. What actually recovers money at that point is a phone call from someone with the authority to agree a payment plan, waive something, or accept that there is a problem with the invoice.

There is also a category question underneath this. Some customers should never enter the sequence at all: the long-standing client who always pays on the twentieth, the commercial account whose purchase ledger runs on its own cycle, the person going through something difficult that you happen to know about. Build an exclusion list and let the owner add to it in one click from any chase notification. That single feature is what makes the difference between a receivables automation the owner trusts and one they quietly turn off. Human-in-the-loop is not a hedge here; it is the design.

The build, step by step

1

Write the policy first

Terms, stage boundaries, what stage three actually threatens, who signs it off, and who is excluded. One page. If you cannot write it, you cannot automate it - you will just be automating an inconsistency.

2

Connect to a sandbox company

Development credentials with a sandbox company, per Intuit's guidance, and production credentials reserved for the live app and live companies. Store tokens encrypted, refresh on schedule, alert on refresh failure. See API key and REST API if any of that is unfamiliar.

3

Schedule the query

Once a day, in the morning, on working days only. Filter to non-zero balance and past due date, compute the age band per invoice from DueDate, and branch to a stage. Weekend sends are a small unforced error - a firm invoice email landing on a Sunday reads as pressure.

4

Apply the suppression rules, then re-check the balance

Exclusion list, dispute flag, payment plan, stage already sent, recently contacted. Then the final balance re-check immediately before dispatch. Log every suppression with its reason so the owner can see what did not go out and why.

5

Send stages one and two, draft stage three

Stage three should arrive in the owner's inbox or chat as a prepared draft with a one-click send and a one-click exclude, plus the customer's phone number and history. The friction is deliberate: it forces a decision without forcing anyone to write the email from scratch.

6

Subscribe to change events as the fast path

Webhooks or Change Data Capture to cancel a pending chase quickly when payment lands, remembering Intuit's documented five-minute aggregation of webhook events. The scheduled query remains the authority; this is what makes the system feel responsive rather than what makes it correct.

7

Report weekly, in plain language

What is outstanding, by age band, what was chased, what was suppressed and why, and what came in. That report is the actual deliverable - the emails are just the mechanism. Observability matters more than usual here, because a receivables automation that stops running looks exactly like a week when everybody paid on time.

If you are pricing this work, what an automation build costs covers the one-off and AI automation cost covers the running side. Accounting practices building this for clients rather than themselves should start with the accounting firm automation page. The two sibling guides worth reading next are quote follow-up automation, which is the same cadence discipline applied at the other end of the job, and automated review requests, which shares this build's most important rule - do not send it while there is an open dispute. On the platform side, the n8n self-hosted cost comparison is relevant if financial data leaving your boundary is a concern, and data residency is the term for that concern.

FAQ

Can I read unpaid invoices from the QuickBooks Online API?
Yes. The Invoice entity in Intuit's Accounting API exposes Balance, DueDate and EmailStatus among its fields, so an open, overdue invoice is one whose Balance is greater than zero and whose DueDate has passed, and the query language supports filtering on those fields. An honest caveat about this page: developer.intuit.com renders its documentation client-side, and our fetches of the Invoice reference and the webhooks pages returned the application shell rather than the reference text. The field names and behaviours here come from Intuit's own pages as surfaced in search, including its help articles - we have not been able to re-read the full reference on the page itself, and you should confirm exact field semantics and the current minor version in the live docs before you build. Checked August 2026.
Does QuickBooks Online have webhooks for payment?
It has webhooks for data-change events on entities your app subscribes to, which is the mechanism you would use to learn that a Payment was created or an Invoice changed. Intuit describes webhooks as a push model that replaces periodic polling, and documents that webhook events are aggregated over a five-minute period - so treat five minutes as your best-case notification latency rather than assuming real time. Intuit also documents Change Data Capture operations, which let you ask for everything that changed since a given timestamp; that is the right tool for catching up after downtime. Again, we could not render Intuit's webhooks reference page directly to quote the full supported-entity list, so verify the entity list against the live documentation.
Do I need a sandbox company to develop this?
Yes, and you should want one. Intuit's guidance is to always use the credentials in the Development section of your developer account with sandbox companies, and that Production credentials are only for live, in-production apps and live QuickBooks Online companies. Two practical consequences: you cannot test against production data with development keys, and you should not be testing an automation that sends money-related emails against a live ledger. Build the whole ladder in the sandbox with fake overdue invoices, watch it run end to end, and only then point it at real customers.
How often can I call the QuickBooks API?
Intuit's published throttling figures, as surfaced from its own developer help material in August 2026, are 500 requests per minute per realm, a maximum of 10 concurrent requests, and 40 batch requests per minute per realm, with the per-realm limit shared between apps connected to the same company. For invoice chasing this is generous - you are running a query a few times a day, not streaming. It matters only if you write a naive job that fetches every invoice individually rather than querying the filtered set, which is a mistake worth avoiding on grounds of taste as well as rate limits.
What should the first reminder say?
As little as possible, and it should not accuse anyone of anything. At one to seven days past due the overwhelmingly likely explanation is that the invoice was missed, filed, or is waiting on someone else in their business. So the first message assumes that: a friendly note, the invoice number and amount, a link to pay, and an offer to resend it if it went astray. No mention of terms, no mention of consequences. The tonal error at this stage is treating a busy customer like a debtor, and it is expensive because the person you have just insulted is also the person who was going to book you again.
When should a human take over?
Before the final rung, not after it. Our recommendation is that stage three is triggered by a person - the automation prepares it, flags it and drafts it, and someone with authority decides to send it and usually phones first. There are two reasons. Practically, by fifteen days past due the automated approach has demonstrably not worked, so repeating it in a firmer font is unlikely to. Commercially, the decision to escalate against a customer is a business relationship decision, and those should not be made by a cron schedule. The automation's job is to make sure nothing slips, not to decide who gets a final notice.
Should I add late fees automatically?
Only if your terms say so, they were on the invoice from the start, and they are lawful where you trade - and even then, we would apply them as a human decision rather than an automatic one. Late fees are a legitimate policy and a terrible surprise. If a fee appears without warning on a customer who simply lost the email, you have converted an administrative delay into a grievance and probably delayed payment further. Automate the calculation and the reminder that a fee is due under the terms; leave the application of it to a person.
Is it worth automating this at all for a small book of invoices?
If you are chasing a handful of invoices a month and you are on top of them, no - build something else first. The case for automating is not the sending, it is the not-forgetting: the invoices that go unchased for six weeks because the week got busy, and the awkwardness of chasing a customer you like, which is why small businesses under-chase far more often than they over-chase. If that describes you, this automation pays for itself by removing a decision you keep postponing. If you already run a tight receivables process, the honest answer is that the gain is modest.

Done for you

Want overdue invoices chased consistently, without damaging a customer relationship?

We build the QuickBooks Online connection, the daily query, the three-stage ladder with your wording, the suppression and exclusion rules, and the stop-on-payment logic that keeps you from chasing money you already have. Stage three lands as a draft for a human. The audit that scopes it is free.

The consult is free, and you keep whatever we build.

Keep building

The rest of the cluster