Make.com automation to gather invoices from mailbox: template and troubleshooting

How The Automation Works — Architecture And Flow

If you want a Make.com automation to gather invoices from mailbox, here’s the quick answer: set a mailbox trigger, filter for invoice emails, download attachments, parse them with OCR/AI, validate and deduplicate, then push clean data into your finance tools and notify the team. This page shows the exact flow, a copyable template, and how to troubleshoot edge cases.

The goal is simple: inbox receipt automation that catches receipts and invoices the moment they arrive, extracts the right data reliably, and updates your systems without human effort. Done well, it supports automated bookkeeping, reduces manual entry, and prevents missing VAT.

Components (Mailbox trigger, attachment download, parser, datastore, notifications)

At a high level, the scenario uses five building blocks working in sequence. Each piece is modular so you can swap tools (e.g., Google Drive vs S3) without breaking the workflow.

• Mailbox trigger: Gmail or IMAP watch module scans for new emails matching your filters.
• Attachment download: Save PDFs, images, or ZIPs to a structured folder path in Google Drive or S3.
• Parser: Use invoice OCR, email parsing, or an AI extraction step to capture fields like invoice number, supplier, date, total, and VAT.
• Datastore: Validate and deduplicate against a hash or composite key, then insert into Airtable receipts, Google Sheets, Xero, or your ERP.
• Notifications: Send a Slack/Teams message or email summary and archive the original message for traceability.

Example Flow Diagram

Below is a linear version of the flow so your team can picture how data moves through the scenario from inbox to accounting.

1. Trigger: Gmail/IMAP watches “Invoices” label/folder with filters (sender, subject, attachment type).
2. Filter: Allow only emails with keywords (invoice, receipt, factuur, facture, bonnetje) or matching regex.
3. Download: Save attachments to Drive/S3 with a path like /Invoices/{Supplier}/{YYYY}/{MM}/original.pdf.
4. Parse: Run PDF parser or OCR/AI; extract fields and line items where available.
5. Validate: Check date formats, VAT ID patterns, totals, currency, and tax math; reject incomplete results.
6. Deduplicate: Compare hash or composite keys; skip duplicates and track attempts.
7. Write: Insert into Airtable/Sheets/Xero; attach file link and raw JSON from parser for audit.
8. Notify: Post a Slack message with status, exceptions, and a link to the stored file.
9. Archive: Apply “Processed” label, move the email to an archive folder, or star it for record-keeping.

Step‑By‑Step Make.com Template — Copyable Scenario

This is the concrete Make.com template you can build today. It’s designed for inbox receipt automation, invoice parsing, and downstream syncing with minimal maintenance. You can learn more about the platform at make.com.

1. Create scenario and choose trigger (IMAP/Gmail)

Pick the watch trigger that matches your email stack. Both Gmail and IMAP triggers support time-based polling and filtering. Start narrow, then widen once you’re confident in precision.

• Gmail: Watch emails in a label like “Finance/Invoices.” Filter for has:attachment to reduce noise.
• IMAP: Watch a dedicated folder like INBOX.Invoices. Use “Download attachments” set to true.
• Set limit: Start with a low limit (5–10 per run) while testing to avoid spamming downstream systems.

2. Download attachments and save to cloud (Google Drive/S3)

Store every attachment for audit. Use a predictable folder structure so your finance team can find files fast. Include a unique run ID or email message ID for traceability.

• Google Drive: Create folder path by year/month. Example: /Finance/Invoices/2025/02/.
• S3: Use a bucket with server-side encryption. Prefix by supplier or domain for easy retrieval.
• Inline vs attachment: If no attachment, convert inline HTML to PDF or extract embedded images.

3. Parse document (PDF parser / OCR / AI)

Invoice automation depends on accurate receipt extraction. Choose email parsing for structured HTML, OCR for scanned PDFs, and AI extraction when layouts vary widely. In practice, a hybrid yields the best coverage.

• Email parsing: Extract totals, VAT, and invoice numbers from HTML if the email body contains the invoice.
• OCR: Works on images and scanned PDFs; good with clear fonts and high contrast.
• AI extraction: Use a vetted prompt for “invoice OCR” plus vendor/total/date validation rules.

4. Validate fields and deduplicate

Stop bad data at the gate. Validate formats (dates, currencies, VAT IDs), recalculate totals, and flag mismatches. Then deduplicate using hashes or composite keys.

• Field checks: Required fields include invoice number, supplier name, invoice date, total amount, and VAT.
• Math checks: Subtotal + VAT = Total; allow for rounding of ±0.01.
• Dedup keys: Hash file content; or combine supplier + invoice number + date.

5. Insert into Airtable/Sheets/Xero

Push clean records to your system of record. For Airtable receipts, create a table with normalized fields and link to a “Suppliers” table. Keep the raw file URL handy.

• Airtable: Fields for “Invoice Number,” “Supplier,” “Date,” “Net,” “VAT,” “Total,” “Currency,” “File URL,” “Source Email.”
• Google Sheets: One row per invoice with a hyperlink to the stored PDF.
• Xero or ERP: Use the appropriate connector; map tax rates and currency codes carefully.

6. Notify finance team and archive email

Send a clear summary so the team can act if needed. Then archive the email to avoid duplicate processing and keep the inbox clean.

• Slack/Teams: “3 invoices processed, 1 requires review (missing VAT).” Include a link to the Drive/S3 folder.
• Archive: Move to “Processed,” apply a label, or add a custom header to mark completion.
• Exception queue: If validation fails, route to a review list or a dedicated channel.

Configure Mailbox Triggers And Filters

Strong filters are the secret to reliable email receipts automation. They slash false positives, reduce compute costs, and improve data quality. Start precise, then iterate as you learn your vendor patterns.

Choosing Gmail vs IMAP triggers

Use Gmail if you’re on Google Workspace and want native label filtering and high reliability. Choose IMAP if you’re on custom mail servers or shared inboxes outside Google.

• Gmail pros: Simple label queries, strong uptime, easy authentication.
• IMAP pros: Works with any provider, flexible folder structures.
• Throughput: Gmail modules may be slightly faster at polling; IMAP offers universal compatibility.

Using filters: subject, sender, keywords, attachment type

Combine sender whitelists, subject patterns, and attachment MIME types to cut noise. Include localized keywords to catch European suppliers.

• Sender: Accounts payable addresses and known supplier domains.
• Subject: “invoice,” “receipt,” “factuur,” “facture,” “bonnetje,” “VAT.”
• Attachments: application/pdf, image/jpeg, image/png, application/zip.
• Body keywords: “Total,” “BTW,” “TVA,” “VAT,” “Invoice No.”

Handling inline invoices vs attachments

Some suppliers include invoices in the email body, not as attachments. Detect and parse accordingly.

• HTML detection: If no attachments, check for “Total,” currency symbols, and tables in HTML.
• Inline images: Extract and OCR embedded images; stitch multi-image pages where needed.
• Fallback: Convert HTML to PDF for consistent storage and downstream processing.

Don't Forget To Use Different Names For An Invoice (Bonnetje, Factuur, Receipt)

Europe is multilingual. If your filters only look for “invoice,” you will miss emails. Include synonyms like bonnetje, factuur, facture, and receipt so your Make.com automation to gather invoices from mailbox captures everything.

Common keywords per language (NL/FR/EN: bonnetje, factuur, facture, invoice, receipt)

Seed your keyword list with real-world synonyms to expand recall without inviting noise. Start with the ones your suppliers actually use.

• Dutch (NL): factuur, bon, bonnetje, btw, creditnota
• French (FR): facture, reçu, TVA, avoir
• English (EN): invoice, receipt, bill, credit note, VAT
• Extras: “Tax invoice,” “Pro-forma,” “Order confirmation” (optional if you want to capture pre-invoices)

Building robust filters: regex and keyword lists (example regex)

Regex helps match variations without bloating filters. Keep it readable for future maintenance and log the hits to prune poor performers.

Example subject/body regex: /(invoice|receipt|factuur|facture|bonnetje)s?/i — add “credit note” terms if you want to catch returns.

• Use word boundaries to avoid false positives (e.g., “invoiced” in a thread).
• Test regex on a sample mailbox; track false positives and refine.
• Pair regex with MIME type filters to prefer PDFs and images.

Using headers and MIME types to improve detection

Headers are underrated. Suppliers often include X-Mailer or List-Id that uniquely identify them. Use that to tighten filters without risking misses.

• Header filters: From, Reply-To, List-Id, X-SES, X-Mailer.
• MIME: Force “has:attachment” and prefer application/pdf to reduce parsing complexity.
• Priority: If List-Id matches a newsletter, skip it—even if the subject says “invoice.”

Tagging and normalization: map synonyms to a canonical 'invoice' label

Normalize everything to a canonical label so reporting stays clean. Whether the email says bonnetje, factuur, or receipt, tag it “invoice.”

• Map NL/FR/EN synonyms to “invoice.”
• Store the original term as metadata if you need analytics by language.
• Use the canonical label for folder names and Airtable select fields.

Parsing Options — OCR, AI And Email Parsing Modules

There’s no single best parser for all files. Combine email parsing for HTML receipts, OCR for scans, and AI for weird PDFs. That hybrid approach keeps extraction accuracy high and exceptions low.

Native Make.com parsers vs external OCR (Google Vision, Tesseract, OCR.space)

Start with Make-native modules where possible for speed and simplicity. Add external OCR for edge cases like low-contrast scans or skewed images.

• Native modules: Faster, fewer moving parts; ideal for clean PDFs and structured HTML.
• Google Vision: Strong OCR accuracy, supports multi-language; good for restaurant receipts.
• Tesseract: Open-source, flexible with pre-processing; needs more tuning.
• OCR.space: Handy API for quick wins; watch rate limits and cost tiers.

AI extraction modules and prompt examples (high-level)

AI shines when vendor layouts vary. Use a system prompt that demands structured JSON and strict validation rules. Keep prompts short and deterministic.

• Fields: invoice_number, supplier_name, invoice_date (ISO), currency, subtotal, vat_amount, vat_rate, total, line_items[].
• Constraints: Sum line items, validate VAT math, return ISO dates, include confidence scores per field.
• Fallback: If confidence < 0.8 for required fields, return status “needs_review.”

Handling scanned, low-quality, and multi-page PDFs

Pre-processing boosts OCR accuracy dramatically. For noisy scans, denoise and deskew. For multi-page PDFs, stitch totals across pages and confirm last-page summaries.

• Image cleanup: Grayscale, thresholding, deskew, DPI normalization.
• Layout detection: Identify tables and totals blocks; handle page footers that repeat.
• Multi-page strategy: Aggregate totals; if multiple totals found, choose the last page’s summary.

Mapping To Your Systems — Airtable, Google Sheets, Xero, Other ERPs

After extraction, consistent mapping is everything. A clean field map avoids rework and powers search, reporting, and reconciliations across tools.

Standard field map template (invoice number, supplier, date, total, VAT)

Use a standard schema so new connectors can be added without reengineering. The essentials below work across most accounting stacks.

• Identity: invoice_number, supplier_name, supplier_email, supplier_vat_id
• Dates: invoice_date, due_date, received_date, period_month
• Amounts: subtotal, vat_amount, total, currency, vat_rate
• Files/refs: file_url, original_email_id, parser_raw_json, status (ok, needs_review)

Deduplication strategies (attachment hash, invoice+supplier composite key)

Duplicates happen—resends, forwards, and monthly summary PDFs. Use both content and semantic keys to stay safe.

• Attachment hash: SHA-256 of the file prevents exact duplicates.
• Composite key: supplier_name + invoice_number + invoice_date catches format changes.
• Soft dedup: If amounts match but date differs by ≤3 days, flag for review.

Example: Airtable base schema and Make.com mapping snippet

For Airtable receipts, create two tables: “Invoices” and “Suppliers.” Link “Invoices.Supplier” to the “Suppliers” table for consistent names and VAT IDs.

• Invoices: Invoice Number (text), Supplier (link), Date (date), Due Date (date), Subtotal (currency), VAT (currency), Total (currency), Currency (single select), File URL (URL), Status (single select), Email ID (text).
• Suppliers: Name (primary), VAT ID (text), Email (email), Default Currency (single select).
• Mapping: Set “Supplier” via a Find-or-Create step keyed on supplier name or VAT ID.

Troubleshooting & Edge Cases

No automation is perfect on day one. Bake in diagnostics and recovery so small hiccups don’t derail the flow. Below are the issues we see most and how to fix them quickly.

Common failures and quick fixes (OCR misses, missing fields)

When OCR misses fields, first check input quality. Then compare parser outputs to validation rules and escalate only what’s necessary to human review.

• Missing invoice number: Use regex to detect patterns like INV-12345 in text layers or file names.
• No totals found: Re-run OCR with higher DPI or switch to AI extraction for that vendor.
• Wrong currency: Infer from symbol, supplier default, or bank country code; never guess silently.

Passworded PDFs, zipped attachments, and images inlined in HTML

Suppliers love “security.” Your scenario needs to handle it gracefully without blocking the pipeline.

• Passworded PDFs: If you have shared passwords, store them securely and attempt decryption; otherwise route to manual review.
• ZIP files: Unzip, iterate attachments, and process each file; reject archives larger than your size threshold.
• Inline images: Extract CID-embedded files and OCR them; if multiple, merge into one PDF for storage.

Testing strategy: test inbox, sample files, replay failed runs

A tight testing loop accelerates stability. Use a staging mailbox and a pack of known invoices to validate each change.

• Test inbox: Clone filters and labels; send 10–20 diverse samples (clean PDF, scan, image-only, HTML-only).
• Golden set: Keep a folder of “known good” invoices to regression-test after changes.
• Replay: Enable detailed logs and rerun failed operations with captured inputs to debug fast.

Security, GDPR And Cost Considerations

When you automate invoices in the EU, privacy and cost discipline matter. Keep data secure end to end and keep operations lean so your automation scales without surprise bills.

Mailbox access best practices (service accounts, limited scopes)

Grant only what’s needed and centralize credentials. Rotate secrets on a schedule and log access by component.

• Service accounts: Avoid personal tokens; use shared credentials with strong 2FA.
• Least privilege: Limit to a specific label/folder and read-only where possible.
• Audit: Log who changed filters and connectors, plus when and why.

Data retention, encryption, and GDPR tips for EU companies

Minimize what you store, encrypt at rest and in transit, and honor data subject rights. Keep a retention policy your DPO can sign off on.

• Retention: Delete raw emails after X days once the invoice is safely stored; keep PDFs for the legal period.
• Encryption: Use Drive/S3 encryption and HTTPS for all transfers.
• Data subject rights: Store the minimum personal data; document your lawful basis for processing.

Estimate operations cost and ways to reduce runs

Costs come from polling, OCR/AI calls, and writes to external systems. Reduce frequency, batch when possible, and skip already-seen emails to save budget.

• Polling: Increase intervals during off-hours; trigger on label changes where supported.
• Parsing: Only OCR when no text layer is detected; cache vendor layouts.
• Writes: Upsert instead of insert where possible; deduplicate early to skip unnecessary steps.

Monitoring, Maintenance And Scaling

A stable Make.com template is only as good as its monitoring. Add alerts, version your changes, and know when it’s time to level up to a dedicated AP solution.

Alerts, logs, and health checks

Alert on failures, volume anomalies, and unusually high OCR error rates. Healthy pipelines are boring pipelines—make deviations obvious.

• Daily digest: Count processed invoices, exceptions, and duplicates.
• Threshold alerts: If exception rate >10% or zero invoices for a day, ping the team.
• Synthetic checks: Send a test invoice weekly; fail loudly if it doesn’t land in your system.

Versioning and staging scenarios

Never edit production blind. Clone to staging, test with your golden set, and promote with a changelog. Rollback should be one click.

• Branching: Keep “Prod” and “Stage” scenarios in parallel.
• Change control: Document filter and parser updates with timestamps and owners.
• Rollback: Archive prior versions so you can revert instantly if metrics dip.

When to graduate to a dedicated AP automation platform

Make.com shines for agile builds and custom flows. Move to a dedicated AP platform when invoice volume, 3-way matching, or approvals get complex enough that you need opinionated workflows.

• Signals: 1,000+ invoices/month, multi-entity accounting, strict approval policies.
• Features: Automatic PO matching, vendor portals, native ERP integrations at scale.
• Hybrid: Keep Make.com for intake and routing, while the AP platform handles approvals and payments.

Want Help Building This? Contact 6th Man To Ship It Fast

You can ship this in days, not months. We’ve built inbox-to-ledger automations for e‑commerce and B2B teams across Europe—fast, reliable, and GDPR‑friendly. If you want a Make.com automation to gather invoices from mailbox without babysitting, we’ll get you there.

What we deliver: scenario, connectors, docs, SLA

We act as your embedded growth and automation team—no fluff, just working systems. You’ll get a production-ready scenario, clean connectors, and docs your team can own.

• Production scenario with filters, OCR/AI parsing, validation, and deduplication.
• Mappings to Airtable receipts, Google Sheets, Xero, or your ERP.
• Runbooks, error handling, and alerts—plus an SLA for support.

Explore how we approach automation and growth in our automation services, see real results in our case studies, and read more practical playbooks in our SEO & digital marketing articles. If you want to understand how we work differently, check out 6th Man vs agencies.

Quick next steps and contact link (CTA)

Want this live next week? We’ll scope it on a short call, build a staging scenario, then ship to production with monitoring. No long projects. No vague deliverables.

• Share your mailbox type (Gmail/IMAP) and storage preference (Drive/S3).
• Provide 10 sample invoices for filter and parser tuning.
• Confirm your target system (Airtable, Sheets, Xero, ERP) and field map.

Let’s automate the boring work so your team can focus on growth. Contact our team to get started.