Olmec Dynamics
H
·7 min read

How to Automatically Save Xero Expense Receipts to Google Drive and Notify Slack Using Make.com

Automate Xero expense receipt saves to Google Drive and Slack alerts with Make.com, using receipt idempotency, deterministic filenames, and error routing.

Introduction

If you handle expense receipts manually, you already know the loop. Someone exports receipts from Xero, downloads PDFs, renames them to something searchable, uploads to Google Drive, then remembers to tell the right person in Slack.

That breaks quickly when volume increases. Filenames drift, duplicates show up after retries, and Slack becomes either spammy or too quiet. This is the kind of Cross-Platform Automation (XPA) workflow you want to be deterministic end-to-end.

By the end of this guide, you will know how to build a Make.com scenario that pulls Xero expense receipts, uploads them to Google Drive with reliable naming, and posts Slack notifications using a dedupe ledger so “upload once” is actually true.

What You'll Need

  • Xero access
    • Your Xero tenant must have expenses enabled
    • Make.com must be able to call the Xero module(s) you use for expenses and receipt attachments
  • Google Drive access
    • A dedicated folder structure, for example Xero Receipts/{year}/{month}/
    • The Make.com connected Google account must have permission to upload files
  • Slack access
    • A Slack app authorized in Make.com
    • Target channels, recommended: one for operational failures (for example #receipts-errors), optionally one for success notifications
  • Make.com
    • A Make.com scenario builder account
    • Connections for Xero, Google Drive, and Slack
  • A dedupe store (pick one)
    • Make.com Data Store, or Google Sheets
    • You need a stable unique key for each receipt

Note: the quality of your receipt dedupe key is the difference between “set and forget” and “why are there duplicates.” Ideally you use the receipt id or attachment id Xero returns. If you only have expense-level ids, you will build a composite key.

Also, if you want background on how we structure Cross-Platform Automation (XPA) workflows around reliability patterns, start from Cross-Platform Automation (XPA).

How It Works (The Logic)

At a high level your Make.com XPA follows this sequence:

  1. Trigger when a new expense receipt is available in Xero
  2. Build a receiptKey (your unique idempotency key)
  3. Dedupe lookup in a ledger (Data Store or Google Sheets)
  4. If already processed, stop (or route to a skipped branch)
  5. Fetch the receipt binary from Xero
  6. Upload once to Google Drive using deterministic filenames
  7. Write the processed record to the ledger only after Drive upload succeeds
  8. Post to Slack, typically error-only to keep signal clean

Trigger → Dedupe → Fetch receipt → Upload Drive → Ledger write-back → Slack notification

Step-by-Step Setup

1) Choose the receipt idempotency key

In Make.com, decide your receiptKey before you build modules. Your options:

  • Best case: use receipt_id returned by Xero
  • Good case: use expense_id + attachment_file_name (composite key)

Implementation in Make.com:

  • Create variables like:
    • xeroExpenseId
    • xeroAttachmentName
    • receiptKey = xeroExpenseId + ':' + xeroAttachmentName

Gotcha: do not use Drive file name as receiptKey. If you change your naming rules later, dedupe breaks.

2) Create the Drive folder structure

Pick a structure your finance team will actually use:

  • Xero Receipts/{year}/{month}/

If you want vendor-based folders, you can go deeper, but keep it simple first. Complexity creates mapping errors.

3) Create the “Receipts Ledger” in Make.com Data Store or Google Sheets

Ledger fields (or equivalent Data Store properties):

  • receiptKey (unique)
  • xeroExpenseId
  • xeroAttachmentName
  • driveFileId
  • processedAt
  • status (success, failed, skipped)
  • slackStatus (optional)
  • errorMessage (only when failed)

Why this matters: it is your idempotency layer. Every retry uses it.

4) Build the Make.com scenario skeleton

Create a scenario with the module order:

  1. Xero trigger (or a polling step, depending on your Make Xero connector capabilities)
  2. Tools: Set variables (compute receiptKey, folderPath, filename)
  3. Dedupe lookup (Data Store get item by receiptKey, or Google Sheets search rows)
  4. Router/Filter: proceed only when not found
  5. Xero: fetch receipt attachment (return binary + filename metadata)
  6. Google Drive: Upload a file (use deterministic filename)
  7. Ledger write-back (store receiptKey + Drive file id + timestamps)
  8. Slack notification (prefer error-only)

5) Deterministic filename before upload

Build the filename in the variables step. Example:

{xeroExpenseId}_{receiptIdOrAttachmentKey}_{YYYY-MM-DD}_{safeAttachmentName}.pdf

If Xero returns the extension, keep it. If not, infer based on mime type.

Sanitize rules:

  • Replace invalid filename characters with _
  • Trim to a safe length, for example 100 to 120 characters

If you want a reference pattern for deterministic filenames and Drive logging, the approach is similar to our How to Automatically Upload and Rename Gmail Attachments in Google Drive Using Make.com.

6) Upload the receipt binary to Google Drive

In your Google Drive “Upload a file” module:

  • Folder: folderPath (example: Xero Receipts/2026/05/)
  • File name: deterministic filename from the previous step
  • File content: the receipt binary from the Xero attachment fetch step

Gotcha: if file content is not passed as a binary type, Drive uploads will fail or store corrupted data.

7) Only mark processed after Drive upload succeeds

Right after Drive upload succeeds, write to the ledger:

  • receiptKey = receiptKey
  • driveFileId = driveFileId
  • processedAt = now
  • status = success

Critical ordering rule:

  • Do not write status = success to the ledger before the Drive upload step completes.

If you mark processed early and Drive upload fails, your dedupe logic will prevent retries from ever fixing the missing file.

8) Slack notifications that don’t spam

Use error-only Slack messaging for most teams.

Error path Slack message should include:

  • receiptKey
  • xeroExpenseId
  • Xero attachment name
  • error summary
  • (optional) which Drive folder you attempted

This keeps Slack usable. If you do want success notifications, keep them short and only send for high-value expenses or new vendor categories.

9) Add an error handler in Make.com

Set Make.com scenario error handling to route failures to an error branch that:

  • writes ledger status failed with errorMessage
  • posts to #receipts-errors

Also make sure your scenario does not mark the ledger as processed on error.

10) Test like production

Run these tests before enabling the scenario:

  • Happy path: one expense receipt uploads once, ledger contains receiptKey
  • Retry path: force a retry, verify dedupe prevents a second Drive upload and second Slack message
  • Failure path: temporarily break Drive permissions, verify ledger is failed and Slack gets an error

Real-World Business Scenario

A mid-sized accounting firm uses Xero for expenses and keeps receipts in Google Drive for audit and internal review. Before automation, an admin spent about 45 minutes per week downloading receipts and renaming them consistently.

After deploying this Make.com XPA:

  • every new Xero receipt landed once in Xero Receipts/{year}/{month}/
  • filenames were predictable, so staff could find the right receipt without asking
  • failures produced a Slack alert with enough context to re-run safely

The day-to-day win was speed, but the bigger win was trust. Once the ledger-based idempotency is in place, duplicates become extremely rare, not a “guess and check” problem.

Common Variations

1) Route by expense type to different Drive folders

If Xero provides an expense category or department mapping, use it to build folderPath and optionally pick different Slack channels.

2) Success notifications only for “exceptions”

Add a filter so Slack success messages only post when:

  • receipt type is non-PDF
  • file size is above a threshold
  • receiptKey is composite (more error-prone)

3) Add Notion as an audit viewer

If you want finance stakeholders to browse receipt processing status in a dashboard, log to Notion in addition to the ledger. For a similar audit pipeline design, you can compare patterns to our How to Sync Xero Invoice Events to Notion and Slack Using Xero Webhooks and Make.com.

A reliable receipts pipeline you can maintain

You built a Make.com Cross-Platform Automation that uploads Xero expense receipts into Google Drive exactly once per receiptKey, using deterministic filenames. You also added a ledger-based dedupe strategy and an error-only Slack notification path so failures are visible and safe to retry.

If you want this tailored to your exact Xero receipt fields, Drive folder rules, and Slack channels, Olmec Dynamics builds these workflows for real teams. You can start by exploring Cross-Platform Automation (XPA) and then see what we do here.