Olmec Dynamics
H
·7 min read

How to Notify Slack When a New Xero Bill Needs Approval Using Xero and Make.com

Automatically notify Slack when a new Xero bill requires approval using Xero webhooks and Make.com. Includes idempotency, filtering, and Slack message template.

Introduction

Approving supplier bills is a small but frequent choke point: a bill lands in Xero, someone has to notice it, check the details, and escalate for approval. That often means opening Xero, running a filter, then copying a line into Slack or email. You either miss things or chase people manually.

This guide shows a simple Make.com workflow that listens for new Xero bill events, filters to bills that require approval, prevents duplicate alerts, and posts a concise, actionable Slack message to the right channel or approver. By the end you'll have a reliable alert that reduces turnaround time for approvals.

What you'll know by the end: the exact Make.com modules to use, the field mapping to include in Slack, and a minimal idempotency pattern using Google Sheets so alerts are sent once per bill.

What You'll Need

  • Xero account with API/webhook access and permission to subscribe to bill events (Xero webhooks require a connected Xero app)
  • Slack workspace with an Incoming Webhook or bot token able to post into the approval channel
  • Make.com account (paid recommended for webhook reliability and error handlers)
  • A Google Sheets file to act as a lightweight dedupe ledger (optional but recommended)
  • Permissions in Make.com to connect Xero, Slack, and Google Sheets

Notes: Xero webhooks may retry delivery. The idempotency ledger prevents duplicate Slack alerts when that happens.

How It Works (The Logic)

Trigger: Xero sends a webhook when a new bill is created. Make.com receives the payload, extracts the bill id and key fields, checks the ledger to see if the bill was already alerted, applies filters (for example: bill status is AUTHORISED vs PENDING or amount over a threshold), then posts a single Slack message containing the supplier, amount, due date and a direct link to the Xero bill. After a successful post the scenario writes the bill id into Google Sheets so the same bill will not trigger again.

Trigger (Xero webhook) → Parse bill payload → Dedupe check (Google Sheets) → Filter for approval-worthy bills → Post Slack message → Write ledger row

Step-by-Step Setup

  1. Decide which Xero bill events matter

Before you build, decide what should alert the team. Common rules:

  • New bill created and status is AUTHORISED or SUBMITTED (depends on your Xero workflow)
  • Bill amount above a threshold, e.g. > 500
  • Supplier is in a whitelist of vendors requiring manual approval

Keep the rule narrow to avoid alert fatigue.

  1. Create a Google Sheet for dedupe (optional but recommended)

Create a simple sheet named xero-bill-alerts with columns:

  • bill_id
  • supplier
  • amount
  • alert_sent_at
  • slack_ts
  • status

This sheet will prevent duplicate alerts when Xero retries webhooks.

  1. Create a new Scenario in Make.com and add a webhook trigger
  • Add a Custom Webhook module in Make.com. Copy the provided webhook URL.
  • In the Xero developer console create a webhook subscription for bill events (e.g. Bill/Created or the general financial resource if you prefer) and paste the Make.com URL.
  • Test by creating a sample bill in Xero and confirming Make.com receives the payload.

Gotcha: Xero includes an event id and resource id. Use the bill resource id as your canonical key.

  1. Parse the Xero webhook payload and extract fields

Add a Tools/Set variables or JSON parse step and extract:

  • xero_bill_id (resource id)
  • supplier_name
  • supplier_id
  • amount (total or amount due)
  • currency
  • due_date
  • status (if provided)
  • bill_url (construct your Xero bill URL if you know the account/tenant pattern)

If the webhook payload is partial, call the Xero GET Bills API with the bill id to fetch full details.

  1. Dedupe check against Google Sheets
  • Add a Google Sheets Search rows step and look for bill_id in the ledger sheet.
  • If a row exists, stop the scenario. That prevents duplicates on webhook retries.
  • If not found, continue.

Implementation detail: do the search first, but only append the ledger row after the Slack post succeeds. That ensures we do not mark a bill as alerted if Slack or Make fails.

  1. Add a filter for approval-worthy bills

Add a Make.com filter after the dedupe check. Example conditions you might use:

  • amount greater than 500
  • OR supplier_name is in a specific list (use a small lookup table in the scenario or Google Sheets)
  • AND status equals PENDING or SUBMITTED depending on your Xero setup

If the bill does not match the filter, optionally write a ledger row with status skipped and stop.

  1. Post an actionable Slack message

Add the Slack module to post a message to your approvals channel. Use a short, scannable block or simple text. A good message includes:

  • Header: New bill awaiting approval
  • Supplier: Acme Ltd
  • Amount: 1,250.00 GBP
  • Due: 2026-06-10
  • Link: Open bill in Xero (make the link the rake to the bill)
  • Quick action hint: Reply in thread with APPROVE or REJECT or include a button that links to your approval workflow (if you have one)

Example plain message text:

New bill awaiting approval

Supplier: Acme Ltd
Amount: 1,250.00 GBP
Due date: 2026-06-10
Xero: <https://app.xero.com/AccountsPayable/Bill/{{xero_bill_id}}|Open bill>

If your Slack messages can include Blocks, build a compact Block Kit with an Open bill Action.OpenUrl button. Blocks render better on mobile.

  1. Append the ledger row only after Slack succeeds

After the Slack post returns success, append a row to Google Sheets with: bill_id, supplier, amount, alert_sent_at (now), slack_ts (message timestamp), and status alerted.

This ordering ensures duplicates are avoided and gives you a traceable audit.

  1. Add an error path to handle failures

If Slack posting fails or Google Sheets write fails, route the scenario to an error branch that:

  • Writes a failed row to the ledger with the error message, or
  • Posts a detailed message to a private ops Slack channel with the full Xero payload and the Make run id so someone can retry manually.

Use Make.com's built-in retry for transient errors like network timeouts.

  1. Test end-to-end

Test these cases:

  • Bill that matches approval rules, confirm Slack alert and ledger row.
  • Bill that fails the filter, confirm skipped ledger row.
  • Re-send the same webhook (or call the webhook URL again) and confirm no duplicate alert.
  • Simulate Slack failure (temporary webhook removal) and confirm the scenario writes a failed ledger row and notifies ops.

Real-World Business Scenario

A services company used this exact pattern to catch supplier bills above their approval threshold. Before automation, approvers missed a few supplier invoices and payments were delayed. After implementing the Make.com webhook workflow, every high-value bill produced a one-line Slack alert with a direct Xero link. The finance lead moved from manual inbox scanning to a reliable team channel, and approval times dropped from two days to a few hours.

If you prefer a richer approval flow, combine this pattern with the Xero invoice sync into Notion described in our guide How to Sync Xero Invoice Events to Notion and Slack Using Xero Webhooks and Make.com to keep an auditable ledger and more context for the approver.

Common Variations

  • Auto-create a ClickUp task for each bill instead of Slack if your approvals live in ClickUp. Post the ClickUp task link back to Slack for quick action.
  • Add a Slack interactive button to the alert that calls a Make.com webhook which in turn updates Xero (if you need a click-to-approve path). That requires careful permissioning because the action writes to Xero.
  • Add cost-centre routing: read a custom supplier property or parse the account code and post to a department-specific Slack channel.

Final notes

This is a small, reliable automation: Xero webhook → Make.com parse → dedupe → filter → Slack alert → ledger write. It removes the manual inbox check and ensures approvers see the bills that matter. If you want help building the scenario, wiring a click-to-approve action back into Xero, or integrating a ClickUp approval task, Olmec Dynamics builds these automations for real businesses. For a related alerting pattern for overdue invoices see our QuickBooks overdue alert guide: How to Automatically Alert Slack When a QuickBooks Online Invoice Becomes Overdue Using Make.com.