How to Automate Shopify Invoice Generation with Make.com and Google Drive

If you are processing more than 30 Shopify orders a day and still generating invoices manually — either through a Google Docs template you copy-paste, or a third-party app that costs $40/month per store — you are burning time and money on a workflow that can be fully automated without writing a single line of code.

I built this exact pipeline for a DTC (direct-to-consumer) skincare brand running on Shopify. They were generating PDFs by hand from a Notion template, emailing them individually, and storing nothing in a structured way. After setting up the Make.com + Google Drive workflow described below, the same process now runs in under 90 seconds per order with zero human intervention — including a branded PDF invoice auto-saved to a customer-specific folder in Google Drive.

This tutorial covers the complete build: from configuring the Make.com Shopify trigger, mapping order line items using the Iterator + Array Aggregator module combo, generating a styled Google Doc invoice, converting it to PDF, and organizing it in Google Drive. I will also walk through every error I ran into and how to fix it.

Section 1: Architecture Overview

Before touching a single module in Make.com, I always sketch the data flow on paper. Here is the architecture this workflow uses:

The trickiest part of this entire workflow — and the part most tutorials skip — is Steps 3 and 4. A Shopify order can contain multiple products. If you try to map line_items directly into a Google Doc placeholder without iterating and aggregating first, you will get only the first item, or an [object Object] error, or an empty field. I will cover this in detail in Section 4.

Section 2: Setting Up Your Google Docs Invoice Template

Your Google Docs template is the backbone of the entire output. The way Make.com replaces content is through exact string matching — it scans the document for the placeholder text you define and swaps it with live data. The format I always use is double curly braces with a descriptive label: {{ORDER_NUMBER}}, {{CUSTOMER_NAME}}, etc.

Step 2.1 — Create the Template Document

In Google Drive, create a new Google Doc and name it something like INVOICE TEMPLATE — DO NOT EDIT. I always add that warning because team members will inevitably open it and accidentally overwrite a placeholder, which breaks every future invoice.

Design your invoice layout. At minimum it should include the following placeholder fields:

• {{ORDER_NUMBER}} — Shopify order name (e.g., #1042)
• {{ORDER_DATE}} — formatted date of the order
• {{CUSTOMER_NAME}} — shipping address name field
• {{CUSTOMER_EMAIL}} — contact email
• {{SHIPPING_ADDRESS}} — full shipping address block
• {{LINE_ITEMS}} — the aggregated product block (critical — more on this below)
• {{SUBTOTAL}}, {{DISCOUNT}}, {{SHIPPING}}, {{TAX}}, {{TOTAL_PRICE}} — financial fields
• {{PAYMENT_METHOD}} — pulled from payment_gateway field in Shopify

Step 2.2 — Get the Template File ID

Once your template is ready, copy the Google Doc URL. The File ID is the long alphanumeric string between /d/ and /edit in the URL. For example:

https://docs.google.com/document/d/1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OhNj5a7XY/edit

File ID: 1BxiMVs0XRA5nFMdKvBdBZjgmUUqptlbs74OhNj5a7XY

Save this ID — you will paste it into the Google Docs module in Make.com later.

Section 3: Building the Make.com Scenario

Step 3.1 — Create a New Scenario

Log in to Make.com and click Create a new scenario. Do not use a template — build this from scratch so you understand every connection point.

Step 3.2 — Configure the Shopify Trigger Module

Click the first module slot and search for Shopify. Select the Watch Events module — not Watch Orders. Here is why: Watch Events uses Shopify webhooks directly, which means your scenario fires in real time the moment the event occurs. Watch Orders uses polling (it checks on a schedule), which introduces delay and wastes Make.com operations.

In the Watch Events configuration panel:

1. Connect your Shopify store by entering your store subdomain (e.g., yourstore.myshopify.com) and generating a private app API key with read_orders scope enabled.
2. Set Event Type to Orders / Order paid. This maps to the orders/paid webhook topic in the Shopify API.
3. Leave the Webhook URL field as auto-generated — Make.com registers the webhook with Shopify automatically.

Step 3.3 — Add a Filter: Financial Status Check

Between the trigger and the next module, right-click the connector arrow and select Add a filter. Set the condition as:

financial_status | Equal to (text, case insensitive) | paid

This prevents the workflow from running on orders that are pending, refunded, voided, or partially_paid.

Step 3.4 — Map Core Order Fields

Add a Tools > Set Multiple Variables module after the filter. This is where I stage all the scalar fields before passing them downstream. Map the following variables from the Shopify trigger output:

Use formatDate() for order_date — Shopify returns timestamps in ISO 8601 format. Without formatting, your invoice will show that raw string, which looks unprofessional.

Check also: Auto-Sync Airtable to Google Calendar via Make.com

Section 4: Handling Line Items — Iterator and Array Aggregator

This is the section where most Make.com tutorials fall apart. A Shopify order contains a line_items array — each element is a product with its own title, quantity, price, SKU, and variant. You cannot paste a raw array into a Google Docs placeholder. You need to iterate over it and rebuild it as a formatted string.

Step 4.1 — Add the Iterator Module

After the Set Multiple Variables module, add a Flow Control > Iterator module. In the Array field, map it to the Shopify trigger's line_items array: {{1.line_items[]}}.

The Iterator will now process each line item as a separate bundle, one at a time.

Step 4.2 — Add the Array Aggregator Module

Directly after the Iterator, add a Flow Control > Array Aggregator module. This is what collapses the individual bundles back into one output that can be passed to Google Docs.

Configure it as follows:

• Source Module: Select the Iterator module you just created.
• Aggregated Fields: Add a text field. In the value, build your line item row format:

{{iterator.title}} | Qty: {{iterator.quantity}} | Price: ${{iterator.price}} | SKU: {{iterator.sku}}

• Row Separator: Set this to \n (new line). Each product will appear on its own line in the Google Doc.

Section 5: Generating the Google Doc Invoice

Step 5.1 — Copy the Template

Add a Google Drive > Copy a File module. Configure it with:

• File ID: Paste the template file ID you saved in Section 2.
• New Title: Use a dynamic name so each invoice is uniquely identifiable:

Invoice - {{2.order_number}} - {{2.customer_name}}

• New Drive / Folder: Map to a staging folder in Google Drive where copied files will land temporarily before being moved post-conversion.

This copy step is mandatory. You never edit the original template — you always work on a disposable copy. I learned this the hard way when an early version of this workflow had a bug that wiped placeholder text from the master template, forcing a full rebuild.

Step 5.2 — Replace Placeholders in the Copy

Add a Google Docs > Replace Text in a Document module. In the Document ID field, map it to the File ID output from the Copy a File module in Step 5.1 — not the template ID.

Add one replacement entry per placeholder. In the Search for field, enter the exact placeholder string including braces. In the Replace with field, map the corresponding variable:

Make.com processes all replacements in a single API call to the Google Docs batchUpdate endpoint. This is efficient but means if one placeholder fails to match (due to a typo or formatting mismatch), the entire replacement block completes without erroring — it simply skips the unmatched field. Always verify the output document after a test run.

Section 6: Converting to PDF and Organizing in Google Drive

Step 6.1 — Download the Google Doc as PDF

Make.com does not have a native Google Docs to PDF conversion module. The correct approach is to use the Google Drive > Download a File module and set the Convert to field to application/pdf.

In the File ID field, map it to the same copied file ID from Step 5.1. When Make.com downloads a Google Docs file with the PDF MIME type specified, Google Drive performs the conversion server-side and returns the binary PDF data as a file bundle.

Step 6.2 — Upload the PDF to the Customer's Folder

Add a Google Drive > Upload a File module. Configure:

• Folder: You can either use a single invoices folder, or dynamically create per-customer folders. For the brand I set this up for, we used a single flat folder named Invoices/2024 with date-stamped file names.
• File Name: Structure it clearly for easy retrieval:

INV-{{2.order_number}}-{{formatDate(now; "YYYYMMDD")}}.pdf

• File Data: Map to the binary output from the Download a File module.
• Convert: Leave this set to No — you are already uploading a PDF, not a Google Workspace file.

Step 6.3 — Delete the Intermediate Google Doc

After the PDF is successfully uploaded, add a Google Drive > Delete a File module. Pass it the File ID of the copied Google Doc from Step 5.1. This keeps your Drive clean — without this step, every order creates an orphaned Docs file that accumulates indefinitely.

Step 6.4 — (Optional) Email the Invoice via Gmail

Add a Gmail > Send an Email module at the end of the chain. Set:

• To: Map to 2.customer_email
• Subject: Your Invoice for Shopify Order {{2.order_number}}
• Body: Write a short transactional message. Avoid marketing language here — this is a receipt, not a newsletter.
• Attachments > File Name: Same naming pattern from Step 6.2.
• Attachments > Data: Map to the binary PDF output from Step 6.1.

Section 7: Common Errors and How to Fix Them

This section is where I document every failure I encountered during initial build and production testing. If you skip straight here after hitting a problem, you are welcome.

Error 1: LINE_ITEMS Placeholder Shows [object Object]

This happens when you map the line_items field from the Shopify trigger directly into the Google Docs replacement field, bypassing the Iterator and Aggregator entirely. Make.com converts the JavaScript array object to the string [object Object] when it cannot serialize it properly.

Fix: Confirm your Array Aggregator is wired correctly. The Source Module must point to your Iterator module. The Aggregated Fields must contain at least one text field with mapped Iterator output. Do not map 1.line_items[] directly into the Docs module under any circumstance.

Error 2: Empty Invoice — All Placeholders Unmatched

This is a Google Docs MIME type mismatch issue. It usually occurs when the file copied in Step 5.1 is not recognized as a Google Docs Mime type (application/vnd.google-apps.document) — for example, if someone saved the template as a .docx and uploaded it to Drive rather than creating it natively in Google Docs.

Fix: Open your template document in Google Drive. Go to File > Save as Google Docs if it was originally a .docx upload. The Google Drive > Copy a File module only supports placeholder replacement on native Google Docs files, not on uploaded Word documents.

Error 3: Shopify Trigger Fires But Filter Blocks All Orders

Check the financial_status filter value. Shopify webhooks can fire the orders/paid event with status paid in lowercase — but if your Shopify store's locale or a third-party payment app returns a different string (such as PAID, Paid, or completed), the case-insensitive text comparison will still catch it. However, some payment gateways (particularly custom-integrated ones) mark orders as authorized rather than paid until manual capture.

Fix: Remove the filter temporarily and run one real paid order through. In the scenario history, click the bundle output from the trigger and inspect the raw value of financial_status. Copy that exact string into your filter condition.

Error 4: Make.com Rate Limit — Error 429 on Google Docs API

If you run a high volume of orders simultaneously — for example, during a flash sale — you may hit Google Docs API rate limits. The limit for the batchUpdate endpoint (which Replace Text uses) is 300 requests per minute per project. Make.com queues requests but does not automatically retry 429 responses in all plan tiers.

Fix: In your Make.com scenario settings, set the Maximum number of cycles to 1 and enable the error handling route. Add a Tools > Sleep module with a 2000ms pause before the Google Docs replacement step. This throttles your throughput to roughly 30 invoices per minute, which keeps you safely under the quota.

Error 5: PDF Download Returns Empty File (0 bytes)

The Google Drive > Download a File module sometimes returns an empty binary if the Google Docs conversion has not completed server-side by the time Make.com issues the download request. This is a race condition — particularly noticeable on large invoices with many line items or embedded images.

Fix: Add a Tools > Sleep module with a 3000ms delay between the Replace Text step and the Download a File step. This gives Google's servers time to finalize the document state before the conversion download is triggered. Three seconds is sufficient in 99% of cases.

Error 6: Duplicate Invoices Being Generated

Shopify can fire the orders/paid webhook more than once if the network request does not receive a 200 OK acknowledgment from Make.com within 5 seconds. Make.com's webhook endpoint is generally fast, but during high-traffic periods, it can timeout on the Shopify side, causing a retry.

Fix: Add a Data Store module at the very beginning of your scenario (before the filter). Use a Make.com Data Store to log processed order IDs. Before running the rest of the scenario, check whether the current order ID already exists in the store. If it does, immediately route to a Terminator module with a success status. This creates an idempotency layer that is essential for any production-grade financial automation.

Section 8: Production Checklist Before Going Live

Before activating this scenario for live orders, go through this checklist. I run this on every automation I deploy for a client:

4. Run the scenario manually with at least three test orders: a single-item order, a multi-item order (3+ products), and an order with a discount code applied.
5. Verify the PDF output for each test — open the file in Google Drive and confirm every placeholder is replaced, line items are formatted correctly, and the total price matches the Shopify order total.
6. Confirm the intermediate Google Doc is deleted from the temp folder after each run.
7. Set up email notifications in Make.com scenario settings for when the scenario encounters an error — go to Scenario Settings > Error Notifications and enter your email. This is mandatory for production.
8. Set the scenario to Active and configure the scheduling. Since this uses a webhook trigger (not a schedule), the scenario runs on demand — you do not need to set a polling interval.
9. Place one live order with a real payment method and confirm the end-to-end output including the Gmail delivery if configured.

Section 9: Performance Benchmarks From a Real Deployment

After deploying this workflow for the skincare brand mentioned at the start, here is what the production metrics looked like after 30 days of operation:

The 4 failed scenarios were all duplicate webhook fires from Shopify, correctly intercepted by the Data Store check. Zero invoices were lost. The average 22-second execution time includes the 3-second sleep buffer before the PDF download.

Section 10: Extensions and Next Steps

Once this base workflow is running cleanly, several high-value extensions are worth building on top of it:

Extension A — Shopify Metafields for B2B Invoices

If your store handles wholesale or B2B customers, you can pull Shopify metafields (such as VAT registration number or purchase order number) using an additional HTTP module that hits the Shopify REST API metafields endpoint. Map the response into additional template placeholders like {{VAT_NUMBER}} and {{PO_NUMBER}}. This turns the same workflow into a fully compliant B2B invoice generator.

Extension B — Multi-Currency Formatting

Shopify returns all monetary values in the store's base currency. If you sell internationally, you will want to pull presentment_money fields instead of shop_money fields from the order JSON. Presentment money reflects the currency the customer actually paid in. Update your Set Multiple Variables module to use 1.total_price_set.presentment_money.amount and 1.total_price_set.presentment_money.currency_code, then add {{CURRENCY}} as a template placeholder.

Extension C — Google Sheets Ledger

Add a Google Sheets > Add a Row module at the end of the scenario. Create a spreadsheet with columns for Order Number, Date, Customer, Total, Payment Method, and Invoice Drive Link. Map all the variables you have already staged into these columns. After 90 days, you will have a searchable financial ledger that your accountant can work with directly — no Shopify exports required.

Final Thoughts

The complete scenario as described above uses 8 modules in Make.com and requires no custom code, no Shopify app subscriptions, and no additional paid tools beyond your existing Make.com plan. The Google Docs conversion to PDF is handled entirely by Google's native infrastructure, which means you are not paying per-conversion fees that apps like DocuSeal or Pandadoc charge.

The two things that separate a reliable production workflow from a fragile demo are the Data Store idempotency check (Section 7, Error 6) and the sleep buffer before PDF download (Section 7, Error 5). Skip either one and you will eventually hit edge cases that generate duplicate invoices or empty PDFs during busy periods.

If you run an error not covered in Section 7, the fastest debugging path is to open the scenario execution history in Make.com, click on the failed run, and expand the output bundle of each module from left to right. The first module where the output shows null, [], or unexpected data is where the problem originates. Work backward from there.

Check also: Notion Database Relations: Build a Custom CRM from Scratch