How to Automate Invoice Sending and Payment Tracking with n8n

Your Invoices Are Running Manually. They Don't Have To.

Sending invoices, chasing late payments, and reconciling what's been paid versus what's outstanding is some of the most tedious work in running a business. It's repetitive, it's high-stakes, and it rarely gets better without a system behind it.

Most freelancers and small teams track invoices in a spreadsheet and send reminders by hand when they remember. Larger teams use accounting software but still manually update statuses and notify the team about overdue accounts.

n8n lets you build a billing pipeline that generates invoices on schedule, sends reminders automatically, and updates your records the moment a payment lands — so you're not chasing money. The system is.

What You Can Automate

Every stage of the invoice lifecycle is automatable with n8n:

• Invoice generation — pull project or order data from a sheet or CRM and build a structured invoice payload on a schedule or trigger
• Automated sending — deliver invoices by email on a fixed day each month, each week, or on project completion
• Multi-touch payment reminders — send a soft reminder at 3 days overdue, a firmer one at 7, and escalate to Slack at 14
• Payment reconciliation — mark invoices paid automatically when a Stripe, PayPal, or bank webhook fires
• Client receipt delivery — email a payment confirmation the moment a charge clears
• AR health digest — weekly summary of outstanding invoices, total overdue amount, and days-outstanding distribution
• Escalation alerts — route invoices past 30 days to a human for a direct call or account review

The Invoice Automation Pipeline

A complete n8n billing system runs three parallel tracks:

Track 1 — Invoice Generation:
Schedule Trigger (monthly) → Google Sheets (client list) → Code (build invoice)
  → Loop Over Items → Gmail (send invoice) → Sheets (log as sent + due date)

Track 2 — Payment Monitoring:
Schedule Trigger (daily) → Google Sheets (invoice log) → Code (compute days overdue)
  → Switch
    → 3 days overdue: Soft reminder email
    → 7 days overdue: Firm reminder email + log escalation flag
    → 14 days overdue: Slack alert to team + firm email
    → 30+ days overdue: Escalation email + Sheets status update

Track 3 — Payment Reconciliation:
Stripe Webhook → Google Sheets (mark paid) → Gmail (send receipt) → Slack (paid notification)

All three tracks write to the same invoice log — one source of truth for your accounts receivable.

1. Collect — Build Your Invoice List

Use a Schedule Trigger set to fire on the first of each month (or your billing cycle). A Google Sheets node reads your client list with columns for client name, email, project, rate, and billing period.

A Code node constructs the invoice object for each row:

const invoices = items.map(item => {
  const client = item.json;
  const invoiceId = `INV-${Date.now()}-${client.client_id}`;
  const dueDate = new Date();
  dueDate.setDate(dueDate.getDate() + 14); // net-14 terms

  return {
    json: {
      invoice_number: invoiceId,
      client_name: client.name,
      client_email: client.email,
      project: client.project,
      amount: client.monthly_rate,
      due_date: dueDate.toISOString().split('T')[0],
      status: 'sent',
    }
  };
});

return invoices;

You now have structured invoice records ready to send and log.

2. Process — Send and Log

Chain a Gmail node to send each invoice as an email with the invoice details in the body or as an attachment. Then write every sent invoice back to a Google Sheets log with:

• Invoice number
• Client name and email
• Amount due
• Due date
• Status (sent)
• Send timestamp

This log becomes the single source of truth that the monitoring workflow reads daily.

3. Route — Overdue Detection

The monitoring workflow runs on a daily Schedule Trigger. A Google Sheets node reads all rows where status is sent (not yet paid).

A Code node computes how overdue each invoice is:

const today = new Date();
return items.map(item => {
  const due = new Date(item.json.due_date);
  const daysOverdue = Math.floor((today - due) / 86400000);
  return { json: { ...item.json, days_overdue: daysOverdue } };
}).filter(item => item.json.days_overdue > 0);

A Switch node then routes each overdue invoice to the right action branch based on days_overdue.

4. Act — Tiered Reminder Sequence

Each overdue tier gets a different message and action:

3 days overdue:

• Gmail node sends a polite reminder: invoice number, amount, and due date with a note to reach out if they have questions
• Google Sheets updates the last_reminder_sent column

7 days overdue:

• Gmail node sends a firmer message with the invoice number, amount, and a direct payment link
• Google Sheets logs an escalation flag

14 days overdue:

• Gmail node sends a final notice requesting immediate payment or a call to discuss
• Slack node posts to your #billing channel: client name, amount, days overdue, and a link to the invoice row

30+ days overdue:

• Gmail node sends a formal overdue notice
• Google Sheets sets status to escalated
• Slack node sends a high-priority alert to trigger manual follow-up

5. Follow Up — Payment Reconciliation and Receipts

When a client pays, a Stripe Webhook (or PayPal, GoCardless, or bank API) fires into n8n. The workflow:

1. Finds the matching invoice in Google Sheets by invoice number or email
2. Updates the row — sets status to paid, records the paid_at timestamp
3. Sends a Gmail receipt to the client confirming payment received
4. Posts a Slack notification to your #billing channel: client name, amount, and the running monthly total

No manual reconciliation. The moment money lands, the record updates and the receipt goes out.

Implementation Patterns

Pattern 1: Monthly Retainer Invoicing

For clients on monthly retainers, run the invoice generator on the first of each month:

Schedule Trigger (monthly, 1st at 9am) → Google Sheets (active retainer clients)
  → Code (generate invoice numbers, compute due date)
  → Loop Over Items
    → Gmail (send individual invoice)
    → Sheets (log each with status: sent)

Use a Loop Over Items node to process each client row separately so an error on one invoice does not block the others.

Pattern 2: Project-Milestone Billing

For project-based work, trigger invoices from a webhook when a milestone is marked complete:

Webhook (milestone completion event) → Code (extract client + milestone data)
  → HTTP Request (fetch project rate from Airtable)
  → Gmail (send milestone invoice)
  → Sheets (log with project ID and milestone name)

This fires immediately when the milestone closes — no waiting for month-end, and the invoice references the specific deliverable.

Pattern 3: Weekly AR Health Digest

Every Friday afternoon, a weekly digest gives you a full snapshot of accounts receivable:

Schedule Trigger (weekly, Friday 4pm) → Google Sheets (all unpaid invoices)
  → Code (aggregate by status and days outstanding)
  → Slack (post summary to #finance)

The Code node computes the summary:

const rows = items.map(i => i.json);
const total = rows.reduce((sum, r) => sum + parseFloat(r.amount || 0), 0);
const overdue = rows.filter(r => parseInt(r.days_overdue || 0) > 0);
const overdueTotal = overdue.reduce((sum, r) => sum + parseFloat(r.amount || 0), 0);

return [{
  json: {
    open_invoices: rows.length,
    total_outstanding: total,
    overdue_count: overdue.length,
    overdue_total: overdueTotal,
    week: new Date().toISOString().split('T')[0],
  }
}];

Your team sees the full AR picture without opening a spreadsheet.

n8n Nodes You'll Use Most

Getting Started

Start with the invoice generation track — it's the simplest and gives you an immediate win.

1. Create your client list in Google Sheets with columns: client_id, name, email, project, monthly_rate, billing_day
2. Build the Schedule Trigger — set it to fire on your billing day at 9am
3. Add the Google Sheets node to read the client list and filter for active clients only
4. Write the Code node to generate invoice numbers and due dates for each row
5. Connect a Gmail node to send each invoice, then add a second Sheets node to log the result with status: sent
6. Test with one real client — trigger the workflow manually and confirm the email arrives and the sheet row updates correctly
7. Build the daily monitoring workflow — once the log is populated, add the overdue detection and reminder branches one tier at a time

The full pipeline — generation, reminders, payment reconciliation, and weekly digest — typically takes a weekend to build and runs itself after that.

For billing workflows that involve recurring subscriptions and trial conversions, see the full guide to n8n SaaS subscription and churn prevention automation. For automating the e-commerce side of payments — orders, refunds, and abandoned cart recovery — see our n8n e-commerce workflow guide.