How to Build a Shopify Fulfillment Delay Alert with n8n

A Shopify fulfillment delay alert in n8n scans your store every morning, finds paid orders that have sat unfulfilled past your shipping window, and sends a single Telegram digest to whoever packs boxes. No paid app, no manual export from the admin. This guide builds the whole thing from scratch with five nodes: a schedule trigger, a Shopify API call, a small filter, a condition, and a Telegram message. You will have it running in about thirty minutes.

Prefer to skip the setup? Grab the ready-made template and be up and running in under ten minutes.

What it does

Every store has a quiet failure mode. An order comes in, the payment clears, and then it slips through the cracks. Maybe the item was on a shelf nobody checked, maybe the packer was out sick, maybe the notification email got buried. The customer paid days ago and is still staring at an “unfulfilled” status. By the time they email to ask, the damage to trust is already done.

This workflow is the safety net. Once a day it asks Shopify a simple question: which paid orders are still unfulfilled and older than my promised window? It collects the answer, formats it into a short list, and posts it to a Telegram chat your team already watches. If nothing is overdue, it stays silent. If three orders are two days late, you see them at 9am with names, ages, and totals, before the customers do.

It sits inside the broader family of n8n Shopify automation flows: small, single-purpose jobs that each remove one recurring manual check from your day.

Why it beats the default

Shopify does show unfulfilled orders in the admin, so why automate it? Because the admin is a place you have to remember to visit. A screen you check “when you get a chance” is a screen you skip on the busy days, which are exactly the days orders pile up. A delay alert flips the model from pull to push. You stop hunting for problems and let the problems find you.

The paid apps that do this are fine, but they charge a monthly fee for a query you can run for free, and they lock the logic inside their dashboard. With n8n you own the threshold, the message wording, the destination, and the schedule. Want the alert only on weekdays? One setting. Want to exclude pre-orders? One line in the filter. Want it in Slack and email? Add two nodes. Nothing about the flow is hidden from you.

There is also the matter of noise. A good alert is quiet until it matters. This one sends nothing when the backlog is clear, so the day it does fire, your team pays attention instead of tuning it out.

What you need

• A working n8n instance, either self-hosted or on n8n Cloud.
• A Shopify store where you can create a custom app and read orders.
• A Shopify Admin API connection in n8n. If you have not set that up yet, follow connect Shopify to n8n, which walks through the 2026 Shopify Dev Dashboard method step by step.
• A Telegram bot token from @BotFather and the chat ID of the group or channel that should receive alerts.

Build time is around thirty minutes from scratch, or under ten minutes if you import the template and drop in your credentials.

Node-by-node list

The whole flow is five nodes in a straight line. Here is the map before we build it.

┌──────────────────────────────────────────────────────────────┐
│  SHOPIFY FULFILLMENT DELAY ALERT                             │
│                                                              │
│  [Schedule Trigger]  daily at 9:00                          │
│         ↓                                                    │
│  [Get Unfulfilled Orders]  Shopify Admin API                │
│         ↓                                                    │
│  [Flag Delayed Orders]  Code: filter by age                 │
│         ↓                                                    │
│  [Any Delays?]  IF delayed_count > 0                        │
│         ↓ true                                               │
│  [Send Telegram Alert]  digest to your team                 │
└──────────────────────────────────────────────────────────────┘
  

Step-by-step build

1 Schedule Trigger

Add a Schedule Trigger node. Set the trigger interval to Days, every 1 day, and pick a fire time that lands before your team starts packing, such as 9:00 in your store’s timezone. Confirm the workflow timezone under Settings so the check runs on your clock, not the server’s.

2 Get Unfulfilled Orders

Add an HTTP Request node named Get Unfulfilled Orders. This asks Shopify for the orders that matter. Configure it like this:

• Method: GET
• URL: https://YOUR_STORE.myshopify.com/admin/api/2026-04/orders.json
• Authentication: Predefined Credential Type, then Shopify Access Token API, and select the credential you created in the connection guide.
• Send Query Parameters: on. Add these five:

Those filters do the heavy lifting server-side. You get back only open orders that are paid and not yet fulfilled, and only the handful of fields you need. Run the node once. The output is a single item whose orders array looks like this:

{
  "orders": [
    {
      "id": 5312002019,
      "name": "#1042",
      "created_at": "2026-07-16T14:22:05-04:00",
      "total_price": "129.00",
      "customer": { "first_name": "Emily", "last_name": "Rodriguez" }
    }
  ]
}

3 Flag Delayed Orders

Add a Code node named Flag Delayed Orders. This is where you decide what “late” means and turn the raw list into a readable message. Set it to run once for all items and paste this JavaScript:

// How many days old before an order counts as delayed
const DELAY_DAYS = 2;

const orders = $input.first().json.orders || [];
const now = Date.now();
const delayed = [];

for (const o of orders) {
  const ageDays = Math.floor((now - new Date(o.created_at).getTime()) / 86400000);
  if (ageDays >= DELAY_DAYS) {
    const name = o.customer
      ? `${o.customer.first_name} ${o.customer.last_name}`
      : 'Guest';
    delayed.push({ order: o.name, ageDays, name, total: o.total_price });
  }
}

delayed.sort((a, b) => b.ageDays - a.ageDays);

const lines = delayed.map(
  d => `• ${d.order} — ${d.ageDays}d old — ${d.name} — $${d.total}`
);

const summary = delayed.length
  ? `⚠️ ${delayed.length} paid order(s) unfulfilled ${DELAY_DAYS}+ days:\n\n${lines.join('\n')}`
  : '';

return [{ json: { delayed_count: delayed.length, summary } }];

Change the single DELAY_DAYS value to match your promise. A same-day store might use 1; a made-to-order shop might use 5. The node outputs one clean item: a count and a ready-to-send summary string.

{
  "delayed_count": 2,
  "summary": "⚠️ 2 paid order(s) unfulfilled 2+ days:\n\n• #1042 — 3d old — Emily Rodriguez — $129.00\n• #1039 — 2d old — Michael Chen — $54.00"
}

4 Any Delays?

Add an IF node named Any Delays? so the workflow stays silent on clear days. Create one condition of type Number:

• Value 1: ={{ $json.delayed_count }}
• Operator: is greater than
• Value 2: 0

Wire the true branch onward to Telegram. Leave the false branch empty. When the backlog is clear, delayed_count is zero, the condition fails, and nobody gets pinged.

5 Send Telegram Alert

Add a Telegram node named Send Telegram Alert on the true branch. Choose your Telegram bot credential, set the operation to Send Message, put your group or channel ID in Chat ID, and set the Text field to an expression:

={{ $json.summary }}

Save the workflow and toggle it Active. That is the whole build. Tomorrow at 9am it runs on its own.

Common mistakes

A few things trip people up on the first run. None are hard to fix.

Cost at realistic volume

This is about as cheap as automation gets. The Shopify Admin API is free on every plan. A Telegram bot is free. The only variable is where n8n runs.

Even if you run it hourly instead of daily, you are looking at roughly 720 tiny API calls a month, still free and still far under Shopify’s limits. Compare that to a $15 to $30 monthly app that does the same single query.

Frequently asked questions

Related guides

• Shopify new order alert with n8n — get pinged the moment an order comes in.
• Shopify shipping confirmation email with tracking — close the loop once you do fulfill.
• Shopify low stock alert with n8n — catch the stock problems that cause delays.
• Browse the full Shopify automation library for more n8n workflows.