How to Automate Invoice Processing With Make

Build a five-module Make scenario that turns a spreadsheet row into a PDF invoice and emails it to the client — steps, line items, reminders, and costs.

By Galactic News Editorial · Published 2026-11-09T07:37:54+00:00 · Updated 2026-11-09T07:37:54+00:00

How to Automate Invoice Processing With Make

You can automate invoice processing with Make by building a scenario that watches for new invoices, pulls out the key fields, creates a document from a template, converts it to PDF, and emails it to the client. Make connects your apps with visual modules, so no code is needed. The most common setup uses Google Sheets, Google Docs, Google Drive, and Gmail. This guide walks through that build step by step.

Make, formerly Integromat, is a visual automation platform. A scenario is a chain of modules. Each module does one job. When the first module fires, the data flows down the chain. Make bills in credits. One credit is charged for each module that runs, except routers and filters, which do not use credits. The Free plan includes 1,000 credits per month and two active scenarios. Paid plans start at $9 per month for Core with annual billing.

What You Need Before You Start

Gather four things before you open Make. First, a Make account. The free tier works for testing. Second, a Google account with Sheets, Docs, and Drive. Third, an invoice template in Google Docs with placeholders for the fields that change, such as client name, date, line items, and total. Fourth, a place to store your invoice data, usually a Google Sheet.

Your sheet should have one row per invoice. Useful columns include client name, client email, invoice date, due date, line items, amount, and status. Add a status column from the start. It prevents the scenario from sending the same invoice twice.

How to Automate Invoice Processing With Make: The Scenario

The scenario has five modules. Each one is simple on its own. Together they form a complete pipeline from data to delivered PDF.

Step 1: Watch for new rows. Create a new scenario in Make. Add the Google Sheets module called Watch New Rows. Connect your Google account. Select your spreadsheet and sheet. This module fires each time a row is added. It is the trigger for the whole scenario.

Step 2: Create the invoice document. Add the Google Docs module called Create a Document from a Template. Select your invoice template. Map each placeholder in the template to the matching column from the sheet. Client name goes to the name placeholder. The amount goes to the total placeholder. Check every mapping twice. A wrong mapping puts the wrong value on a real invoice.

Step 3: Convert the document to PDF. Add a Google Drive module to export the new document as a PDF. This gives you a file you can attach to an email and store in a client folder. Keep the file name consistent, for example with the invoice number and client name.

Step 4: Email the PDF to the client. Add a Gmail module, or the Email module if you use another provider. Set the recipient to the client email column from your sheet. Attach the PDF from the previous module. Write a short, professional message body. Include the invoice number and due date in the subject line.

Step 5: Mark the row as sent. Add a Google Sheets module called Update a Row. Set the status column to Sent. This is the step that stops duplicates. Without it, the scenario may send the same invoice again on the next run.

Test the scenario with a row of sample data before you use it with clients. Run it manually. Check the PDF. Check the email. Check that the status column updates. Fix any mapping errors now, while the stakes are low.

Handling Line Items Correctly

Line items are the trickiest part of this build. An invoice can have several products or services. If you map the line items field straight into the template, you may get only the first item, or an error, or an empty field.

The fix is to use an Iterator and an Array Aggregator. The Iterator loops through each line item in the data. The Aggregator rebuilds the items into one formatted text block. That block then maps cleanly into the template placeholder. This pattern applies whether your data comes from a sheet, a shop, or a CRM.

If your source is Shopify, use the Watch Events module instead of watching a sheet. It fires in real time when an order is paid. Add a filter so the scenario only runs when the payment status is paid. That skips test orders and unpaid ones.

Automating Unpaid Invoice Reminders

Creating invoices is only half the job. Chasing unpaid ones is the other half. Make can do that too. The official Make guide for unpaid invoices uses Stripe, Google Sheets, and Slack.

The scenario searches Stripe for invoices with an open status. It writes them to a Google Sheet. A filter keeps only invoices that are 10 days past their due date. A router then splits the flow. If the customer has one unpaid invoice, Make emails the customer a reminder with the PDF attached. If the customer has more than one, Make escalates to management on Slack.

A companion scenario removes paid invoices from the sheet. That keeps the reminder list clean. Together, the two scenarios close the loop from invoice to payment.

Make Invoice Automation: Costs and Limits

Cost depends on how many modules run. Each module run costs one credit for most apps. A five-module scenario that processes 100 invoices a month uses about 500 credits. That fits inside the free plan's 1,000 credits. A busier business needs a paid plan.

Core starts at $9 per month with annual billing, or $10.59 billed monthly, for 10,000 credits. Pro starts at $16 per month with annual billing and adds priority execution, custom variables, and full-text log search. Teams starts at $29 per month with annual billing and adds team roles and shared templates. All paid plans include unlimited active scenarios and one-minute scheduling. The free plan allows two active scenarios and a 15-minute minimum interval.

Watch the execution limit too. The free plan caps a single scenario run at 5 minutes. Paid plans allow 40 minutes. Long invoice batches can hit the free cap. Split large batches or upgrade if runs start timing out.

Common Mistakes and How to Avoid Them

The most common mistake is sending an invoice twice. It happens when the scenario has no status check. Always filter for rows marked unsent, and always update the status after sending. Check the Import History or execution log after the first few runs.

The second mistake is mapping the wrong field. Money fields are unforgiving. A total in the tax field, or a date in the amount field, produces a wrong invoice. Test with sample data and read the output before you activate the scenario.

The third mistake is auto-sending too early. Keep amounts human-approved until the scenario has run cleanly many times. Create drafts instead of sending, if your invoicing tool supports it. Auto-send only when the amounts, tax settings, and client details are proven correct.

The fourth mistake is ignoring errors. Make logs every run. A failed module stops the chain. Check the execution history regularly, especially in the first weeks. Set up error handling so a failed run notifies you instead of failing silently.

Bottom Line

Automating invoice processing with Make takes five modules: watch for new rows, create the document from a template, convert it to PDF, email it, and mark the row as sent. Use an Iterator and Aggregator for line items. Add a status column to prevent duplicates. Test with sample data before going live. Keep money fields human-approved until the scenario is proven. The free plan covers light volume. Core at $9 a month covers most small businesses. Start with one invoice type, prove it works, then extend the same pattern to reminders and payment tracking.