Automate Invoice Reminders and AR Chasing with n8n

The Money's Owed; Nobody's Asking for It

Late invoices rarely go unpaid because the client refuses. They go unpaid because nobody followed up, the follow-up felt awkward, and "send a reminder tomorrow" became next month. Accounts receivable is mostly a memory problem.

You can automate invoice reminders with n8n so the follow-up happens on schedule, with the tone escalating as the days pile up: a gentle nudge first, a firmer note at two weeks, a final notice near thirty days. And when an invoice crosses the line where a bot shouldn't be the one chasing, the workflow pulls a human in over Slack.

The trick isn't sending emails. It's knowing where each invoice sits in the ladder and not sending the wrong tone at the wrong time.

What You Can Automate

• Days-overdue math: every unpaid invoice scored daily against its due date
• Tiered tone: gentle, firm, and final reminders that match how late the payment is
• Send-once logic: a record of what's been sent so a client never gets the same tier twice
• Internal escalation: a Slack alert when an invoice passes 30 days or a big-ticket threshold
• Payment detection: a paid invoice drops out of the ladder automatically
• Register-driven: the whole thing reads from the invoice register your billing workflow already writes

The Reminder Pipeline

The chase runs as one daily pass over open invoices:

Schedule Trigger (daily 9am)
  → Google Sheets / DB (read unpaid invoices)
  → Code (compute days_overdue + current tier)
  → Switch (route by tier)
      → gentle  (3–13 days)  → Gmail (friendly nudge)
      → firm    (14–29 days) → Gmail (firmer reminder)
      → final   (30+ days)   → Gmail (final notice) + Slack (#ar-escalations)
  → Google Sheets (log tier + date sent)

The Switch keyed on days overdue is the engine. Everything else is sending the right message and remembering you sent it.

1. Read the open invoices

The first node pulls unpaid invoices from your register — the same sheet or table the generation workflow writes. Filter to status unpaid so paid ones never enter the chase. If a payment webhook marks invoices paid in near-real time, this filter is also your automatic exit from the ladder.

2. Compute days overdue

A Code node subtracts each invoice's due date from today and attaches a days_overdue and a tier. Keep the date math in one place:

const today = $now;
return $input.all().map(item => {
  const inv = item.json;
  const due = DateTime.fromISO(inv.due_date);
  const days = Math.floor(today.diff(due, 'days').days);
  let tier = 'none';
  if (days >= 30) tier = 'final';
  else if (days >= 14) tier = 'firm';
  else if (days >= 3) tier = 'gentle';
  return { json: { ...inv, days_overdue: days, tier } };
});

3. Route by tier

A Switch node sends each invoice down its tier's branch. Don't collapse this into one email with conditional text; separate branches keep each tone's copy clean and make it obvious in the execution log which message went out.

4. Send and escalate

Each branch sends its Gmail message. The final tier does one extra thing: it posts to a Slack #ar-escalations channel so a human knows this account needs a call, not a fourth email. In practice, the email-only chasers fail right here — they keep emailing a client who's gone quiet instead of flagging that it's time for a person.

5. Log what you sent

Write the tier and the date back to the register. Next run reads it and won't re-send the same tier, so a client gets one gentle nudge, not seven. This send-once memory is the difference between a helpful reminder and harassment.

Implementation Patterns

Pattern 1 — Escalate tone, then escalate to a human. The ladder shouldn't end with the bot. The final tier emails the client and pings a person. An automated chaser that never hands off is the one that emails a client who's already disputing the charge. Self-hosted n8n runs this daily for free, so there's no per-execution reason to skip the careful tiering.

Pattern 2 — Send-once via a logged tier. Idempotency matters here as much as in any pipeline. Store the last tier sent per invoice and gate each branch on "haven't sent this tier yet." Without it, a workflow that runs daily sends the gentle nudge every single day for eleven days. Costly to your sender reputation, and annoying.

Pattern 3 — Exit on payment. A paid invoice should leave the ladder the moment it's paid. A Stripe or bank webhook that flips the register row to paid means the next daily run simply doesn't see it. No awkward "reminder" the day after they paid.

n8n Nodes You'll Use Most

Getting Started

1. Point the read node at your invoice register and filter to unpaid.
2. Write the days-overdue Code node and check the tiers against a few known invoices.
3. Add the Switch node with your day thresholds.
4. Write each tier's email copy in its own Gmail node; keep the tones distinct.
5. Add the Slack escalation on the final branch.
6. Add the log-tier-sent write-back and the send-once IF gate.
7. Run it once against test data, confirm nobody gets a double, then schedule it.

To skip designing the ladder, the InvoiceChase: Automated AR Follow-up ships the tiered chase with the days-overdue math, the send-once logging, and the Slack escalation already wired together.

The chase only works if the invoices exist and the register is clean, which is what the n8n invoice generation workflow sets up upstream. For the payment-matching and reconciliation side, the n8n invoice automation guide covers how a paid invoice exits the ladder. When chasing extends to supplier-side payments, the Vendor Payment Escalator applies the same tiered logic to outbound bills.