How to Parse Invoices in Make (Formerly Integromat) — No Code Required

Make (formerly Integromat) is a visual workflow automation tool that connects apps and APIs without requiring code. If you receive invoices by email and want them automatically extracted and routed to a spreadsheet, accounting software, or internal system — this guide shows how to build that workflow from scratch.

No programming required. Total setup time: 20–30 minutes.

What You'll Need

• A Make account (free tier works for testing — make.com)
• A DocuParse API account — sign up free at docuparseapi.com, 20 documents/month, no credit card
• A destination for the extracted data (Google Sheets, Airtable, Xero, or any app Make supports)

The Workflow We're Building

Step 1 — Create a New Scenario in Make

1. Log into Make and click Create a new scenario
2. You'll see a blank canvas with a prompt to choose your first module

Step 2 — Add the Email Trigger

If your invoices arrive by email:

1. Search for and select Gmail (or your email provider)
2. Choose Watch Emails as the trigger
3. Connect your Gmail account when prompted
4. Configure the trigger:
   • Folder: INBOX (or a dedicated AP folder)
   • Criteria: Only emails with attachments
   • Maximum number of results: 10 (adjustable)

If you want to trigger manually for testing: Use the Manual trigger (clock icon) while building and switch to email later.

Step 3 — Add the HTTP Module (DocuParse API Call)

This is the core of the workflow. The HTTP module sends your invoice file to DocuParse API and returns the extracted JSON.

1. Add a new module after the email trigger
2. Search for HTTP and select Make a Request
3. Configure it as follows:

URL:

Method: POST

Headers: Click Add item and add:

• Name: Authorization
• Value: Bearer YOUR_API_KEY_HERE

(Replace YOUR_API_KEY_HERE with your actual key from the DocuParse API dashboard)

Body type: Multipart/form-data

Fields: Click Add item:

• Key: file
• Value: Click the file icon and map to the attachment from the email trigger (Attachments[] > Data)
• Content type: application/octet-stream

Parse response: Toggle this to Yes — this tells Make to parse the JSON response automatically so you can map the fields in later modules.

This first request returns a document_id, not the extracted fields. Add two more modules to fetch the result:

4. Add Tools → Sleep and set the delay to 10 seconds.
5. Add HTTP → Make a request (GET):

On Starter and Pro you can replace Sleep + GET with a Make Custom webhook trigger that receives the finished result.

Step 4 — Map the Extracted Fields

After adding the GET module, run the scenario once with a test email to populate the response structure. Make will show you all the available fields from the fetched result:

Step 5 — Write to Google Sheets

1. Add a Google Sheets module after the GET module
2. Choose Add a Row
3. Connect your Google account
4. Select your spreadsheet and sheet
5. Map the columns to the extracted fields:

Your invoice spreadsheet now fills itself automatically every time a new email arrives.

Step 6 — Handle Extraction Failures

Not every PDF will extract successfully. Add error handling before the Google Sheets step:

1. Add a Router module after the GET module
2. Create two routes:
   • Route 1: Filter condition: data.status = completed → proceed to Google Sheets
   • Route 2: Filter condition: data.status = failed → send a Slack message or email alert

Slack notification for failures:

Complete Module Configuration Reference

HTTP Module Settings (submit)

HTTP Module Settings (get result)

Router Conditions

Success route:

Failure route:

(The 3 refers to the submit HTTP module and 5 to the GET module — adjust if your scenario has a different numbering)

Sending to Xero Instead of Google Sheets

Replace the Google Sheets module with an HTTP module calling the Xero API, or use Make's native Xero module:

1. Add a Xero module
2. Choose Create Invoice (this creates a payable bill)
3. Map the fields:
   • Contact Name: data.merchant
   • Invoice Number: data.invoice_id
   • Date: data.date
   • Due Date: data.due_date
   • Total: data.total
   • Currency Code: data.currency

Make's Xero module handles the authentication; you just connect your Xero account.

Alternative Trigger: Google Drive

If invoices are dropped into a Google Drive folder rather than emailed:

1. Replace the Gmail trigger with Google Drive > Watch Files in a Folder
2. Set the folder to your invoice intake folder
3. The rest of the workflow is identical — map data (the file content) to the HTTP module's file field

Testing Your Workflow

1. Click Run once in Make while in the scenario editor
2. Send a test email with a PDF invoice to your Gmail
3. Make will process one email and show you the data at each step
4. Check the GET module output to see the full API response
5. Check Google Sheets to confirm the row was created

If the HTTP module shows an error:

• Verify your API key is correct (check the DocuParse API dashboard)
• Confirm the attachment is being mapped correctly — it should be binary data, not a URL
• Check that Parse Response is set to Yes

Monthly Cost

• Make free tier: 1,000 operations/month (each module execution = 1 operation; a 3-module workflow uses 3 per invoice)
• DocuParse API free tier: 20 documents/month, no credit card
• For higher volume: the Starter plan (see current pricing)

At 100 invoices/month, the Make Core plan ($9/month) plus DocuParse API free tier (or the Starter plan if over 20) is well under $25/month total.

Next Steps

• DocuParse API docs — full response format and error codes
• n8n invoice parsing guide — the open-source alternative
• Zapier receipt parsing guide
• Full Python integration for developers
• Try it on your document — no sign-up