Shopify & E-commerce

This Shopify returns automation with n8n turns a messy returns inbox into a clean, trackable process. A hosted return request form verifies the order against the Shopify Admin API, tags the order Return requested, appends the request to a Google Sheets RMA log, and emails the customer an acknowledgment. No returns app subscription, no manual order lookups, and every request recorded in a sheet you own. Build time is about 40 minutes.

Prefer to skip the build? Grab the ready-made template from the CTA below and be running in under 10 minutes.

What it does

Returns are the part of running a store that quietly eats hours. A customer emails “I want to send this back,” and now someone has to find the order, confirm it exists, decide if it qualifies, tag it so fulfillment knows, write the reply, and note it somewhere so nothing slips. Do that thirty times a week and you have lost most of a workday to copy-paste.

This workflow takes the intake off your plate. A customer fills in a short return request form. n8n looks the order up in Shopify to confirm it is real, then tags the matching order with Return requested so it shows up in a saved Shopify view for your fulfillment team. It writes a row to a Google Sheets RMA log with a return number, the reason, and a status of Requested. Finally it emails the customer a friendly acknowledgment with their RMA number and what happens next.

What it deliberately does not do is issue money. Refunds and replacements stay a human decision inside Shopify. The automation removes the busywork around that decision, not the decision itself. This sits in the same family as the refund tracker, which logs refunds after the fact; this one runs at the front of the process, when the request first arrives.

Why it beats the default

The default is one of two things: a shared inbox where return requests get lost between order confirmations, or a paid returns app that charges a monthly fee and still keeps your data locked inside its own dashboard.

A plain inbox has no structure. There is no single place to see every open return, no automatic tagging, and no guarantee the customer even got a reply. Requests fall through when things get busy, and busy is exactly when returns spike.

A dedicated returns app fixes the structure but adds a recurring cost and another login, and the return records live in a system you do not control. If you cancel the app, you often lose easy access to the history.

This n8n approach gives you the structure without the lock-in. Tagging happens automatically, every request lands in a spreadsheet you can filter and export, the customer always gets a same-minute acknowledgment, and the whole thing runs on tools most stores already use. You own the data and the logic end to end. For the wider picture of what you can wire into your store this way, see the n8n Shopify automation guide.

What you need

• An n8n instance (Cloud or self-hosted), version 1.0 or newer.
• A Shopify store with Admin API access. Set this up with the 2026 Dev Dashboard method described in connect Shopify to n8n. The custom app needs read_orders and write_orders scopes.
• A Google account for Google Sheets, connected in n8n by OAuth2.
• A Gmail account for the customer acknowledgment email, also connected by OAuth2.
• A blank Google Sheet with a header row for the RMA log (columns listed further down).

The workflow uses the Shopify Admin API version 2026-04. No returns app, no third-party service, no blocked messaging channels.

Node-by-node list

Eight nodes, one clean path with a single branch for unmatched orders.

┌──────────────────────────────────────────────────────────────────┐
│  SHOPIFY RETURNS AUTOMATION (n8n)                                   │
│                                                                    │
│  [Return request form] → [Find the order] → [Order found?]         │
│                                                  │ true             │
│                                                  ▼                  │
│                           [Build RMA] → [Tag order] → [Sheets log]  │
│                                                          │          │
│                                                          ▼          │
│                                                  [Email customer]   │
│                                                  │ false            │
│                                                  ▼                  │
│                                          [Flag unmatched → support] │
└──────────────────────────────────────────────────────────────────┘
  

Step-by-step build

1 Return request form (Form Trigger)

Add a Form Trigger node. This gives you a hosted URL you can link from your store. Set the form title to “Request a return” and add these fields: Order number (text, required), Email (email, required), Product name (text), Reason (dropdown: Damaged, Wrong item, Changed mind, Wrong size, Other), and Comments (textarea). When a customer submits, the node outputs one item shaped like this:

{
  "Order number": "1042",
  "Email": "emily.rodriguez@gmail.com",
  "Product name": "Cedar Trail Running Jacket",
  "Reason": "Wrong size",
  "Comments": "Ordered medium, need large."
}

2 Find the order (HTTP Request, GET)

Add an HTTP Request node set to GET. This confirms the order is real and pulls the existing tags so you do not overwrite them. Point it at your store:

GET https://YOUR-STORE.myshopify.com/admin/api/2026-04/orders.json
      ?name={{ $json["Order number"] }}&status=any&fields=id,name,email,tags

Use Header Auth for the credential, with header X-Shopify-Access-Token set to your Admin API access token. The response returns an orders array. A match looks like this:

{
  "orders": [
    { "id": 5218844733, "name": "#1042", "email": "emily.rodriguez@gmail.com", "tags": "VIP" }
  ]
}

3 Order found? (If)

Add an If node. Create one condition using the number comparison “is not empty” or “larger than 0” on the array length:

{{ $json.orders.length }}   →   larger than   →   0

The true output carries on to the return flow. The false output goes to the support-alert email in step 8.

4 Build the RMA record (Edit Fields)

Add an Edit Fields (Set) node. This is where you assemble everything the later nodes need. Add four assignments:

• order_id (number): {{ $json.orders[0].id }}
• rma_number (string): {{ "RMA-" + $json.orders[0].name.replace("#","") }}
• merged_tags (string): {{ ($json.orders[0].tags ? $json.orders[0].tags + ", " : "") + "Return requested" }}
• customer_email (string): {{ $('Return request form').item.json.Email }}

5 Tag the order (HTTP Request, PUT)

Add a second HTTP Request node set to PUT. Send the merged tag list back to the order. In the body section, set Body Content Type to JSON and paste this into the JSON body field:

{
  "order": {
    "id": {{ $json.order_id }},
    "tags": "{{ $json.merged_tags }}"
  }
}

PUT https://YOUR-STORE.myshopify.com/admin/api/2026-04/orders/{{ $json.order_id }}.json

Reuse the same Header Auth credential. After this runs, the order in Shopify shows the Return requested tag, and you can build a saved order view filtered on that tag for your team.

6 Log the request (Google Sheets, Append)

Add a Google Sheets node, operation Append. Point it at your RMA log sheet and map the columns to the fields you built. Set Status to the literal Requested and Date to {{ $now.format('yyyy-MM-dd HH:mm') }}. This gives you a single filterable record of every return that has ever come in.

7 Email the customer (Gmail, Send)

Add a Gmail node, Send operation. Set To to {{ $('Build the RMA record').item.json.customer_email }}, a subject like Your return request {{ $('Build the RMA record').item.json.rma_number }}, and a short friendly body confirming you received the request and will follow up with next steps. Same-minute acknowledgment is what stops the “did you get my email?” follow-ups.

8 Flag unmatched request (Gmail, Send)

Connect a second Gmail node to the false output of the If node. Send it to your support address with the submitted order number and email so a person can reach out. This catches typos and orders from a different sales channel without polluting the returns log.

The RMA log columns

Common mistakes

• Overwriting tags. The single most common error is sending only Return requested in the PUT body, which wipes existing tags. Always merge with the current tags from step 2.
• Wrong order lookup field. The Admin API matches the storefront number on name, not id. Searching by id with a customer-facing number returns nothing.
• Skipping the If node. Without the order-exists check, a typo creates a phantom RMA row and a confusing customer email. The branch keeps your data honest.
• Trusting the form for money. Do not wire an automatic refund onto this. Keep a human between the request and the refund. The tag and the sheet exist so that review is fast, not skipped.
• Forgetting the API scope. A PUT that returns 403 almost always means the app is missing write_orders. Add the scope and reinstall the app.

Cost at realistic volume

Say your store handles 300 return requests a month, which is a healthy volume for a mid-size store.

• Shopify Admin API: free. Each request makes two calls (one GET, one PUT), so 600 calls a month, far under the rate limits.
• Google Sheets and Gmail: free at this scale on a standard Google account. 300 appends and 300 emails is nowhere near any cap.
• n8n: free on self-hosted. On n8n Cloud, 300 runs a month sits comfortably inside the Starter execution allowance.

So the running cost is effectively zero, versus a dedicated returns app that typically starts around ten to thirty dollars a month and scales up with volume. Over a year that is a few hundred dollars saved, plus the hours you get back from not doing manual order lookups.

Frequently asked questions

Related guides

• Shopify refund tracker in Google Sheets with n8n
• Shopify order tagging automation with n8n
• Shopify order status lookup automation with n8n
• More store automations in the Shopify automation category

A shopify inventory reorder point forecast google sheets n8n workflow turns 60 days of paid orders into a sales velocity for every SKU, compares that against stock on hand, and tells you which products to reorder this week and how many units to buy. Eight nodes, one Google Sheet, one Monday morning email. No forecasting app and no per-SKU fee. Below: the node map, the validated build, the mistakes that quietly produce wrong numbers, and the real cost.

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

What it does

Every Monday at 7am the workflow pulls your paid orders from the last 60 days, counts the units sold per SKU, and divides by the window to get a daily sales velocity. It then reads current stock for every tracked variant and asks one question per SKU: at this rate of sale, will the shelf empty before a new delivery could arrive?

The answer comes from the reorder point, which is the velocity multiplied by your supplier lead time plus a safety buffer. If stock has fallen to or below that number, the SKU gets flagged with a suggested order quantity. Everything lands in a Google Sheet, one row per SKU, and the flagged rows arrive in your inbox as a table you can forward to a supplier.

Take a black tee that sold 60 units in 60 days, so one a day. Your supplier takes 14 days and you want a 7 day buffer, putting the reorder point at 21 units. Stock reads 14, already past the line, so the workflow tells you to order 14 units.

Why it beats the default

Shopify tells you how many units you have. It does not tell you how long they will last, and that is the number a purchase order actually needs.

The common substitute is a low stock alert on a fixed threshold, set once and never revisited. A fixed number means different things for different products. Ten units of something selling five a day is a two day emergency. Ten units of something selling five a year is nine years of dead capital. One threshold cannot describe both, so alerts cry wolf on slow movers while fast movers sell out in silence. The Shopify low stock alert is the right tool when you just want to know a shelf is thin. This is the other job: knowing when to buy.

Forecasting apps solve it for 30 to 200 dollars a month, often billed per SKU, and hide the arithmetic behind a dashboard. The arithmetic is division. Once your lead time and buffer are two numbers in one node, you can change the assumptions in ten seconds and watch the whole catalog rerank.

What you need

• An n8n instance, cloud or self-hosted. A free self-hosted install handles this comfortably.
• A Shopify store connected to n8n the 2026 way, with read access to orders and products. See the 2026 connection guide.
• A Google account for Sheets and Gmail, connected to n8n by OAuth.
• One empty Google Sheet with a header row, described in step 2 below.
• Inventory tracking switched on in Shopify for the products you care about. Untracked variants are skipped, because a variant with no stock number cannot have a reorder point.
• Your real supplier lead time in days. The workflow cannot derive this, and it decides whether the output is useful.
• Roughly 25 minutes.

No AI model is involved. A trailing average is arithmetic, and arithmetic does not need a language model. Anything selling you an LLM to divide units by days is selling you a calculator at a markup.

Node-by-node list

Eight nodes in one straight line, no branches.

Every Monday 7am    (Schedule Trigger)
       ↓
Set planning inputs (Edit Fields, v3.4)   lookback, lead time, review, safety, email
       ↓
Get paid orders     (Shopify, order:getAll)   returnAll, financialStatus=paid
       ↓
Get products        (Shopify, product:getAll) returnAll, Execute Once = ON
       ↓
Compute reorder points (Code, run once for all items)
       ↓
Upsert forecast sheet  (Google Sheets, appendOrUpdate, match on sku)
       ↓
Build reorder summary  (Code, run once for all items)
       ↓
Email the reorder list (Gmail, send)

Step-by-step build

1 Add the schedule trigger

Create a new workflow and add a Schedule Trigger. Set the interval to Weeks, trigger day Monday, hour 7, minute 0. Weekly matches how purchasing actually works: you place orders in batches, not continuously, and the review period is part of the math in step 5.

2 Create the Google Sheet

Make a new sheet, name the tab Reorder, and put these headers in row 1, spelled exactly like this because the mapping matches on them:

sku | product | variant | stock | units_sold | velocity_per_day |
days_of_cover | reorder_point | suggested_qty | status | updated_at

Keep the sheet ID from the URL. It is the long string between /d/ and /edit.

3 Add the Set planning inputs node

Add an Edit Fields node and create five assignments: lookbackDays as a Number set to 60, leadTimeDays as a Number set to your supplier’s real turnaround, reviewPeriodDays as a Number set to 7 to match the weekly schedule, safetyDays as a Number set to 7, and reportEmail as a String set to your address.

4 Pull the orders and the catalog

Add a Shopify node, resource Order, operation Get Many, Return All on. Under Options add Status any, Financial Status paid, and Created At Min set to this expression:

{{ new Date(Date.now() - $json.lookbackDays * 86400000).toISOString() }}

Then add a second Shopify node, resource Product, operation Get Many, Return All on. Open its Settings tab and turn on Execute Once. This matters more than it looks: an n8n node runs once per incoming item, and the orders node hands it thousands. Without Execute Once you would fetch the entire catalog thousands of times and hit the rate limit in seconds.

5 Compute the reorder points

Add a Code node named exactly Compute reorder points, because two later nodes reference it by name. Set mode to Run Once for All Items. It counts units per SKU from the orders, then walks the catalog and joins the two.

const cfg = $('Set planning inputs').first().json;
const { lookbackDays, leadTimeDays, reviewPeriodDays, safetyDays } = cfg;

// 1. Units sold per SKU over the lookback window
const sold = {};
for (const o of $('Get paid orders').all()) {
  for (const li of (o.json.line_items || [])) {
    const sku = (li.sku || '').trim();
    if (!sku) continue;
    sold[sku] = (sold[sku] || 0) + (li.quantity || 0);
  }
}

// 2. Join to current stock, one row per variant
const rows = [];
const stamp = new Date().toISOString().slice(0, 10);
for (const p of $input.all()) {
  for (const v of (p.json.variants || [])) {
    const sku = (v.sku || '').trim();
    if (!sku) continue;
    if (v.inventory_management !== 'shopify') continue;

    const stock = v.inventory_quantity || 0;
    const units = sold[sku] || 0;
    const velocity = units / lookbackDays;

    const reorderPoint = Math.ceil(velocity * (leadTimeDays + safetyDays));
    const daysOfCover = velocity > 0 ? Math.round(stock / velocity) : null;
    const target = velocity * (leadTimeDays + reviewPeriodDays + safetyDays);
    const suggestedQty = Math.max(0, Math.ceil(target - stock));
    const needsReorder = velocity > 0 && stock <= reorderPoint;

    rows.push({ json: {
      sku,
      product: p.json.title,
      variant: v.title === 'Default Title' ? '' : v.title,
      stock,
      units_sold: units,
      velocity_per_day: Number(velocity.toFixed(3)),
      days_of_cover: daysOfCover,
      reorder_point: reorderPoint,
      suggested_qty: needsReorder ? suggestedQty : 0,
      status: velocity === 0 ? 'no sales' : (needsReorder ? 'REORDER NOW' : 'ok'),
      updated_at: stamp
    }});
  }
}

rows.sort((a, b) => (a.json.days_of_cover ?? 99999) - (b.json.days_of_cover ?? 99999));
return rows;

Three decisions are worth naming. Variants without inventory_management set to shopify are skipped, because a reorder point on an untracked quantity is fiction. Blank SKUs are skipped, since there is nothing to join them to. And the suggested quantity covers lead time plus review period plus safety, not just lead time, because the next chance to order is seven days away.

Here is what the black tee looks like coming out of this node:

{
  "sku": "TEE-BLK-M",
  "product": "Black Tee",
  "variant": "M",
  "stock": 14,
  "units_sold": 60,
  "velocity_per_day": 1,
  "days_of_cover": 14,
  "reorder_point": 21,
  "suggested_qty": 14,
  "status": "REORDER NOW",
  "updated_at": "2026-07-17"
}

6 Upsert the forecast sheet

Add a Google Sheets node, operation Append or Update Row. Pick your document by ID, sheet Reorder, mapping mode Map Automatically, and set Column to Match On to sku. Matching on SKU is what makes the workflow idempotent: every Monday the same row updates in place instead of appending a duplicate, so the sheet stays one row per SKU and sorts by days_of_cover into a catalog ranked by urgency.

7 Build the summary and email it

Add a second Code node, Run Once for All Items, that filters to the flagged rows and builds an HTML table:

const rows = $('Compute reorder points').all().map(i => i.json);
const flagged = rows.filter(r => r.status === 'REORDER NOW');

let html;
if (flagged.length === 0) {
  html = '<p>Nothing crosses its reorder point this week. ' + rows.length + ' SKUs checked.</p>';
} else {
  const cells = flagged.map(r =>
    '<tr><td>' + r.sku + '</td><td>' + r.product + ' ' + r.variant + '</td><td>' + r.stock +
    '</td><td>' + r.days_of_cover + '</td><td>' + r.reorder_point + '</td><td><b>' + r.suggested_qty + '</b></td></tr>'
  ).join('');
  html = '<p>' + flagged.length + ' of ' + rows.length + ' SKUs need a purchase order.</p>' +
    '<table border="1" cellpadding="6" cellspacing="0">' +
    '<tr><th>SKU</th><th>Product</th><th>Stock</th><th>Days left</th><th>Reorder at</th><th>Order</th></tr>' +
    cells + '</table>';
}

const label = flagged.length === 1 ? ' SKU' : ' SKUs';
return [{ json: {
  subject: flagged.length ? 'Reorder ' + flagged.length + label : 'Reorder check: all clear',
  html,
  count: flagged.length
}}];

Then add a Gmail node, operation Send. Set To to {{ $('Set planning inputs').first().json.reportEmail }}, Subject to {{ $json.subject }}, and Message to {{ $json.html }} with Email Type set to HTML. The all clear email is deliberate. A workflow that only writes when something is wrong is indistinguishable from one that has quietly stopped running.

Save, run it once by hand, and check the sheet fills before you switch Active on. To have the list land in a channel instead of an inbox, swap the Gmail node for Telegram or Slack; the summary node already hands over a finished string, so nothing upstream changes. See Shopify alerts on Telegram.

Common mistakes

The wholesale spike is the one that catches people. A mean has no idea that one of its inputs was unusual, and it will happily tell you to buy 500 more of something you sold once. If bulk orders are normal for you, the honest fix is a median instead of a mean, which is a two line change in the Code node.

Cost at realistic volume

Nothing here bills per SKU, which is the whole argument against the app version.

The only real resource is the two API pulls. A store doing 500 orders a month has about 1,000 orders in a 60 day window and maybe 300 variants, which the Shopify nodes page through in well under a minute. At 5,000 orders a month and 2,000 variants it takes a few minutes, which is unremarkable for something that runs while you sleep.

On n8n Cloud this is four executions a month against your plan allowance. Against 30 to 200 dollars a month for a forecasting app, the sheet wins on cost before you count the part that matters more: your lead time and your buffer are yours to change, and the numbers recompute on the next run.

FAQ

Related guides

The sheet this workflow produces is a planning input. These are the automations around it.

• The full guide to n8n Shopify automation
• How to connect Shopify to n8n in 2026
• Shopify inventory low stock alert, the fixed threshold version for when you just want to know a shelf is thin
• Auto email your supplier on low stock, the step after you approve the buy list
• Auto hide out of stock products, for the SKUs that get away from you
• Shopify weekly best sellers report
• More Shopify automations

A shopify rfm customer segmentation google sheets n8n workflow pulls a year of paid orders every Monday, scores each customer from 1 to 5 on recency, frequency and monetary value, sorts them into named segments, and upserts the table into a Google Sheet. No analytics app, no monthly fee, no CSV exports. Seven nodes and a sheet that tells you who to email this week. Below: the node map, the build, the mistakes, and the real cost.

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

What it does

Shopify Analytics shows you total sales and a list of top spenders. It will not tell you that the customer who spent 1,400 dollars has not been back in ten months, or that the person who ordered four times in six weeks is about to become your best account. Those are different people who need different emails, and a revenue leaderboard hides both.

RFM is the oldest reliable answer to that. You rank every customer on three things: how recently they bought, how often they buy, and how much they have spent. Each becomes a score from 1 to 5, relative to everyone else on your list. A 555 is a Champion. A 255 is someone who used to be a Champion and is drifting away, which is the most valuable email you will send all month. A 111 is gone.

This workflow builds that table for you on a schedule and keeps it current.

• Reads paid orders from a rolling window you set, 365 days by default.
• Groups them by customer email, merging case variants and skipping guest checkouts with no email.
• Scores recency, frequency and monetary value into quintiles, then labels each customer.
• Upserts every row into a Google Sheet keyed on email, so the sheet updates rather than duplicating.
• Emails you a segment breakdown when it finishes.

Why it beats the default

The default is a customer analytics app from the Shopify App Store, at anywhere from 30 to 200 dollars a month depending on list size. Those apps compute RFM competently. The trade is that your segmentation logic lives inside someone else’s product, priced per contact, and you cannot see or change the thresholds. The other default is worse: exporting orders to a spreadsheet by hand every quarter, which works exactly once because nobody keeps it up.

Building it in n8n gives you the part the apps hide. The scoring lives in one Code node you can read in a minute, so a threshold that does not match your store is a one line change rather than a support ticket. The output is a plain Google Sheet, which means anyone on your team can filter it and any other workflow can read it. And because it is your own instance, the price does not move when your customer list doubles.

The honest caveat: an app gives you a dashboard, and this gives you a sheet. If a chart is what you want, this is not that. If acting on the segments is what you want, a sheet is the better input anyway.

What you need

• An n8n instance, cloud or self-hosted. A free self-hosted install handles this comfortably.
• A Shopify store connected to n8n the 2026 way, with read access to orders and customers. See the 2026 connection guide.
• A Google account for Sheets and Gmail, connected to n8n by OAuth.
• One empty Google Sheet with a header row, described in step 2 below.
• Roughly 20 minutes, and enough order history that the scoring has something to divide. See the FAQ on list size.

No AI model is needed here. RFM is arithmetic, and arithmetic does not need a language model. Anything that sells you an LLM for this is selling you a sorting function at a markup.

Node-by-node list

Seven nodes in one straight line, no branches.

Every Monday 6am  (Schedule Trigger)
       ↓
Set window        (Edit Fields, v3.4)      lookbackDays = 365, reportEmail
       ↓
Get paid orders   (Shopify, order:getAll)  returnAll, financialStatus=paid
       ↓
Compute RFM scores (Code, run once for all items)
       ↓
Upsert RFM sheet  (Google Sheets, appendOrUpdate, match on email)
       ↓
Build summary     (Code, run once for all items)
       ↓
Email the summary (Gmail, send)

Step-by-step build

1 Add the schedule trigger

Create a new workflow and add a Schedule Trigger. Set the interval to Weeks, trigger day Monday, hour 6, minute 0. Weekly is the right cadence: RFM bands move slowly, and a daily run mostly rewrites identical rows.

2 Create the Google Sheet

Make a new sheet, name the tab RFM, and put these headers in row 1, spelled exactly like this because the mapping matches on them:

email | name | recency_days | frequency | monetary | last_order_date |
r_score | f_score | m_score | rfm_score | segment | updated_at

Keep the sheet ID from the URL. It is the long string between /d/ and /edit.

3 Add the Set window node

Add an Edit Fields node and create two assignments: lookbackDays as a Number set to 365, and reportEmail as a String set to your own address. Putting these in their own node means you tune the workflow in one place instead of hunting through expressions later.

4 Pull the orders

Add a Shopify node, resource Order, operation Get Many, and turn on Return All. Under Options add Status any, Financial Status paid, and Created At Min set to this expression:

{{ new Date(Date.now() - $json.lookbackDays * 86400000).toISOString() }}

Filtering to paid orders at the source matters. Unpaid and abandoned checkouts are not purchases, and letting them into the scoring inflates frequency for people who never actually bought.

5 Score the customers

Add a Code node named exactly Compute RFM scores, since a later node references it by name. Set mode to Run Once for All Items. The logic does four things in order: group orders by lowercased email, derive recency, frequency and monetary value per customer, rank each of the three into quintiles, then map the scores to a label.

The quintile ranking is the part worth understanding. It sorts the whole customer list on one measure and cuts it into five equal bands, so scores are always relative to your store rather than to a number someone guessed. Recency is inverted, because a low recency in days is good:

function scoreByQuintile(list, key, target, higherIsBetter) {
  const sorted = [...list].sort((a, b) => a[key] - b[key]);
  const n = sorted.length;
  sorted.forEach((c, i) => {
    let q = Math.floor((i / n) * 5) + 1;
    if (q > 5) q = 5;
    c[target] = higherIsBetter ? q : 6 - q;
  });
}

scoreByQuintile(customers, 'recencyDays', 'r', false);
scoreByQuintile(customers, 'frequency',   'f', true);
scoreByQuintile(customers, 'monetary',    'm', true);

Then the labels. These are the rules to argue with once you know your own store, and they are deliberately readable so you can:

function labelFor(r, f, m) {
  if (r >= 4 && f >= 4 && m >= 4) return 'Champions';
  if (r >= 3 && f >= 3)           return 'Loyal';
  if (r >= 4 && f <= 2)           return 'New and promising';
  if (r <= 2 && f >= 4 && m >= 4) return 'At risk, was valuable';
  if (r <= 2 && f >= 3)           return 'At risk';
  if (r <= 2 && f <= 2 && m >= 4) return 'Big spender, lapsed';
  if (r === 1 && f === 1)         return 'Lost';
  if (r === 3)                    return 'Needs attention';
  return 'Hibernating';
}

Order matters in that chain, because the first match wins. The node returns one item per customer, sorted by revenue, each carrying the twelve fields your sheet expects.

6 Upsert into the sheet

Add a Google Sheets node, operation Append or Update Row. Pick your document and the RFM tab, set mapping to Map Each Column Manually, and choose email as the column to match on. Map each remaining field to its matching value from the Code node.

Append or Update is what makes this rerunnable. Plain Append would give you a fresh set of duplicate rows every Monday until the sheet is unusable. Matching on email means week two updates week one’s rows in place.

7 Summarise and email

Add a second Code node named Build summary, also Run Once for All Items. It reads back from the scoring node with $('Compute RFM scores').all(), tallies customers and revenue per segment, and builds a small HTML list. Then add a Gmail node, Send operation, with the address pulled from your config node:

To:      {{ $('Set window').first().json.reportEmail }}
Subject: RFM refresh: {{ $json.total_customers }} customers scored ({{ $json.generated_on }})
Body:    {{ $json.summary_html }}

Run the workflow manually once. You should get an email like this, and a populated sheet behind it:

Champions: 2 customers, 2310 in revenue
At risk, was valuable: 1 customer, 1860 in revenue
Big spender, lapsed: 1 customer, 1400 in revenue
Loyal: 2 customers, 260 in revenue
New and promising: 3 customers, 160 in revenue
Lost: 1 customer, 15 in revenue

That second line is the whole point of the exercise. Activate the workflow and it runs every Monday.

Common mistakes

• Using Append instead of Append or Update. Your sheet grows by a full copy of your customer list every week and the segments become impossible to read. Match on email.
• Leaving unpaid orders in the pull. Abandoned checkouts are not purchases. Without the paid filter, frequency scores drift upward for people who never gave you money.
• Reading recency backwards. A recency of 4 days is excellent and should score 5, not 1. This is the single most common RFM bug, which is why the scoring function takes an explicit flag rather than assuming higher is better.
• Running it on a tiny list. Quintiles need a spread to divide. With fifteen customers the bands are three people wide and one order swings someone from Loyal to Champion. The workflow runs fine, the labels just mean less.
• Renaming the scoring node. The summary node calls it by name, so a rename in the editor breaks the reference. Rename in both places or leave it alone.
• Expecting guest checkouts to appear. Orders with no email cannot be grouped to a person, so they are skipped by design. If a large share of your orders are guest orders, your RFM covers less of your revenue than you think.
• Treating the labels as gospel on day one. Look at fifteen customers in the sheet and check the labels match your instinct. The thresholds are a starting point, not a verdict.

Cost at realistic volume

Nothing here bills per customer, which is the entire argument against the app version.

The only real resource is the order pull. A store doing 500 orders a month has about 6,000 orders in a 365 day window, which the Shopify node pages through in a couple of minutes on a weekly schedule. A store doing 5,000 orders a month will want to trim the lookback to 180 days or run it overnight, but the arithmetic itself stays trivial: it is a sort and a division, on data that fits in memory.

On n8n Cloud this is four executions a month against your plan allowance, which is a rounding error. Compare that to 30 to 200 dollars a month for a segmentation app, and the sheet wins on cost before you count the fact that you can change the rules.

FAQ

Related guides

The sheet this workflow produces is an input. These are the automations that consume it.

• The full guide to n8n Shopify automation
• How to connect Shopify to n8n in 2026
• Shopify customer win-back email, the natural next step for your At risk and Lost rows
• Shopify repeat customer reward email, for the Champions
• Shopify high value customer Slack alert
• Shopify order tagging automation
• More Shopify automations

A shopify birthday discount code email n8n workflow reads customer birthdays from a Google Sheet every morning, finds whoever is celebrating today, generates a unique single-use discount code inside Shopify, and emails it through Gmail. No paid loyalty app, no manual list checking, no shared coupon that ends up on a deal site. You build it once with five nodes and it runs on autopilot. Below you get the node-by-node map, the exact build steps, the common mistakes, and the real cost at volume.

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

What it does

Birthday emails are one of the highest-converting messages an ecommerce store ever sends, because they land when the customer already feels like treating themselves. The problem is that Shopify has no birthday field and no built-in way to trigger something on a date each year. So most owners either pay for a loyalty app or forget the whole idea.

This automation closes that gap with parts you already have. You keep a simple sheet of names, emails, and birthdays. Every morning n8n wakes up, checks the sheet against today’s date, and for each match it asks Shopify to mint a fresh discount code and then sends that code to the customer by email. The customer opens their inbox on their birthday and finds a personal, one-time offer waiting.

• Runs on a daily schedule, fully unattended.
• Creates a unique code per customer, capped at one use.
• Sends a warm, personal Gmail message with the code inside.
• Costs nothing beyond tools you likely already run.

Why it beats the default

The default option is a birthday app from the Shopify App Store. Those work, but they add a recurring bill, they park your customer data inside another vendor, and they usually hand out one static coupon code that anyone can reuse once it leaks. A single shared code on a birthday campaign is a margin risk, because a deal-hunting forum can drain it in hours.

Building it in n8n flips all three problems. There is no monthly fee. The customer list stays in your own Google Sheet and your own Shopify store. And because every code is generated on the fly with a usage limit of one, a leaked code is worthless to anyone but the person it was meant for. You also get to shape the email exactly how you want, in your own brand voice, instead of squeezing into an app’s template editor.

What you need

• An n8n instance, cloud or self-hosted (a free self-hosted install is fine).
• A Shopify store connected to n8n the 2026 way (Developer Dashboard). See the 2026 connection guide.
• A Google account for Google Sheets and Gmail.
• A birthday sheet with three columns: Name, Email, Birthday (stored as MM-DD).

Build time: about 30 minutes from scratch, or under 10 minutes if you import the template and drop in your credentials.

Node-by-node list

The workflow is a clean straight line of five nodes. Nothing branches, which keeps it easy to reason about and easy to fix if a birthday email ever fails to arrive.

┌─────────────────────────────────────────────────────────────┐
│  SHOPIFY BIRTHDAY DISCOUNT CODE EMAIL                        │
│                                                             │
│  [Schedule Trigger]  daily at 08:00                         │
│         ↓                                                   │
│  [Google Sheets]  read all birthday rows                    │
│         ↓                                                   │
│  [Code]  keep today's birthdays, build unique code + dates  │
│         ↓                                                   │
│  [HTTP Request]  Shopify GraphQL: create discount code      │
│         ↓                                                   │
│  [Gmail]  send the birthday email with the code             │
└─────────────────────────────────────────────────────────────┘
  

Step-by-step build

1 Schedule Trigger

Add a Schedule Trigger node. Set it to a fixed interval of once per day and choose an hour that suits your audience, for example 8:00 in your store’s timezone. This node is the only entry point, so nothing else runs until the schedule fires.

2 Google Sheets — read the list

Add a Google Sheets node, operation Get Row(s) in Sheet. Point it at your birthday spreadsheet and the tab that holds the list. Leave the filters empty so it returns every row; the next node does the date matching. A returned row looks like this:

{
  "Name": "Emily Rodriguez",
  "Email": "emily.rodriguez@gmail.com",
  "Birthday": "07-15"
}

3 Code — find today’s birthdays

Add a Code node (run once for all items). This is the brain of the workflow. It compares each row’s birthday to today, and for every match it builds a unique code plus the start and end dates for the offer.

const today = new Date();
const mmdd = `${String(today.getMonth() + 1).padStart(2, '0')}-${String(today.getDate()).padStart(2, '0')}`;
const out = [];

for (const item of $input.all()) {
  const row = item.json;
  const bday = String(row.Birthday || '').replace(/\//g, '-').slice(-5);
  if (bday !== mmdd) continue;

  const rand = Math.random().toString(36).slice(2, 7).toUpperCase();
  const first = String(row.Name || 'FRIEND').split(' ')[0].toUpperCase().replace(/[^A-Z0-9]/g, '');

  const starts = new Date(today); starts.setHours(0, 0, 0, 0);
  const ends = new Date(starts); ends.setDate(ends.getDate() + 7);

  out.push({ json: {
    name: row.Name,
    email: row.Email,
    code: `BDAY-${first}-${rand}`,
    title: `Birthday reward - ${row.Name}`,
    startsAt: starts.toISOString(),
    endsAt: ends.toISOString()
  } });
}

return out;

If nobody has a birthday today, the node returns zero items and the rest of the workflow simply does not run, which is exactly what you want. On a match, one item leaves this node per customer:

{
  "name": "Emily Rodriguez",
  "email": "emily.rodriguez@gmail.com",
  "code": "BDAY-EMILY-7K2QP",
  "title": "Birthday reward - Emily Rodriguez",
  "startsAt": "2026-07-15T00:00:00.000Z",
  "endsAt": "2026-07-22T00:00:00.000Z"
}

4 HTTP Request — create the Shopify code

Add an HTTP Request node. This calls the Shopify GraphQL Admin API to create a real, working discount code with the values the Code node produced. Configure it like this:

• Method: POST
• URL: https://YOUR_STORE.myshopify.com/admin/api/2026-04/graphql.json
• Authentication: Generic credential, Header Auth, header name X-Shopify-Access-Token with your Admin API access token as the value
• Send Body: on, Body Content Type: JSON

Paste this into the JSON body field. It sends the GraphQL mutation with variables pulled from the current item:

={{ JSON.stringify({
  query: "mutation ($basic: DiscountCodeBasicInput!) { discountCodeBasicCreate(basicCodeDiscount: $basic) { codeDiscountNode { id } userErrors { field message } } }",
  variables: { basic: {
    title: $json.title,
    code: $json.code,
    startsAt: $json.startsAt,
    endsAt: $json.endsAt,
    customerSelection: { all: true },
    customerGets: { value: { percentage: 0.15 }, items: { all: true } },
    appliesOncePerCustomer: true,
    usageLimit: 1
  } }
}) }}

That creates a 15 percent code, valid for seven days, that works exactly once. Change 0.15 to set a different discount, or swap percentage for a fixed discountAmount if you prefer a flat sum off.

5 Gmail — send the birthday email

Add a Gmail node, operation Send. Map the fields from the current item so each customer gets their own code:

• To: ={{ $json.email }}
• Subject: =Happy birthday, {{ $json.name }}! A gift from us 🎉
• Message: your birthday copy, with ={{ $json.code }} dropped in where the code should appear

A short, warm message converts best. Something like: “Happy birthday from all of us. Here is 15 percent off anything in the store as our gift. Use code BDAY-EMILY-7K2QP at checkout within the next seven days.” Keep it personal and get the code above the fold.

Common mistakes

• Storing the birth year in the match. If you compare full dates including the year, nobody ever matches. Match on MM-DD only, which the Code node already does.
• Leaving the timezone unset. Without a workflow timezone, the 8am trigger and the “today” check both run in server time, and codes can be built for the wrong calendar day. Set the timezone once in Settings.
• Using a stale API version. Point the URL at a current version such as 2026-04. An old version can silently drop fields from the mutation.
• Trusting the HTTP status alone. Shopify GraphQL answers 200 even on a rejected discount. Always check userErrors before you assume the code exists.
• One shared code for everyone. That defeats the whole point. Let the Code node mint a fresh code per customer with a usage limit of one.

Cost at realistic volume

This is one of the cheapest automations you can run, because none of the moving parts bill per birthday.

Even a store with 20,000 customers rarely sees more than a few dozen birthdays on a single day, so you stay far below every free limit. If you run n8n Cloud instead of self-hosting, this is a single scheduled run per day, which barely dents the starter plan’s execution allowance. For most stores the true cost is zero.

FAQ

Related guides

• The full guide to n8n Shopify automation
• How to connect Shopify to n8n in 2026
• Shopify repeat customer reward email
• Shopify customer win-back email
• More Shopify automations

You already know that repeat and add-on sales are where the margin lives, yet most stores stop talking to a customer the moment the order confirmation goes out. A Shopify AI product recommendation email built in n8n fixes that gap without a paid upsell app. Every new order triggers a workflow that reads what the shopper bought, gathers other products from the same category, and lets Google Gemini choose the three that pair best, then emails them a clean “you might also like” pick.

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

A Shopify AI product recommendation email built in n8n turns every new order into a personalized cross-sell. When an order arrives, the workflow reads what the customer bought, pulls other products from the same category, and lets Google Gemini pick three complementary items to feature in a follow-up email. It runs on free tiers, sends through Gmail, and never invents products, because it can only choose from your real catalog.

What it does

The workflow watches your store for new orders. The instant one is placed, it looks up the product that was purchased, finds sibling products in the same product_type, and hands that shortlist to Gemini with one job: pick the three items that complement the purchase and write a one-line reason for each. Those three products get dropped into an email template and sent to the customer through Gmail.

The result is a recommendation email that feels hand-picked rather than random. Because the candidate list is scoped to a single category and comes straight from your Shopify catalog, every suggestion is a product you actually sell and can actually ship.

┌──────────────────────────────────────────────────────────────┐
│  SHOPIFY AI PRODUCT RECOMMENDATION EMAIL                      │
│                                                              │
│  [Order placed]                                              │
│       ↓                                                      │
│  [Shopify Trigger] → [Get purchased product] →               │
│       [Get same-category products] → [Build candidates] →    │
│            [Gemini picks 3] → [Build email] → [Gmail send]   │
└──────────────────────────────────────────────────────────────┘
  

Why it beats the default

Shopify’s built-in “related products” block on a product page is passive. It only helps a shopper who is already browsing, and it disappears the moment they check out. Paid recommendation apps close that gap but add a monthly fee and often a percentage of revenue on top.

This n8n approach reaches the customer in their inbox, right after a purchase, when intent is highest and the brand is fresh in mind. You control the category logic, the email copy, and the send timing. There is no per-order fee, no shared revenue, and no third-party script slowing your storefront. For the broader picture of what else you can wire up this way, see our guide to Shopify automation with n8n.

What you need

• A running n8n instance, either n8n Cloud or self-hosted.
• A Shopify store with Admin API access. If you have not connected n8n to Shopify yet, follow our 2026 Shopify to n8n connection guide, which covers the current Dev Dashboard method.
• A Google Gemini API key on the free tier, using the gemini-2.5-flash model.
• A Gmail account connected to n8n for sending the emails.

Build time is around 30 to 45 minutes from scratch, or under ten minutes if you import the template.

Node-by-node list

Seven nodes carry an order from placed to recommendation email.

1. Shopify Trigger fires on the orders/create topic the moment a new order is placed.
2. An HTTP Request node reads the purchased product so the workflow knows its product_type.
3. A second HTTP Request node pulls other active products in that same product_type.
4. A Code node trims the list into clean candidates, removes the item that was just bought, and attaches the customer name and email.
5. An HTTP Request node calls Gemini and asks it to pick the three best matches as JSON.
6. A Code node parses Gemini’s answer and builds the email HTML.
7. A Gmail node sends the recommendation email to the customer.

Step-by-step build

1 Shopify Trigger (orders/create)

Add a Shopify Trigger node and set the topic to Order Created. Attach your Shopify Access Token credential. This node hands the full order object to the rest of the workflow. The fields that matter here are the first line item’s product_id and the customer block.

{
  "id": 5123400012345,
  "customer": { "first_name": "Emily", "email": "emily.rodriguez@gmail.com" },
  "line_items": [
    { "product_id": 7781234500001, "title": "Cedar & Sage Candle", "price": "28.00" }
  ]
}

2 Get purchased product (HTTP Request)

Order line items do not include the product category, so fetch the product directly. Use an HTTP Request node with the GET method and your Shopify credential as a predefined credential type.

GET https://YOUR_STORE.myshopify.com/admin/api/2026-04/products/{{ $json.line_items[0].product_id }}.json

The response gives you product.product_type, for example Candles, which becomes the filter for the next step.

3 Get same-category products (HTTP Request)

Now pull a shortlist of sibling products. Another GET request filters the catalog by the category you just found and limits the pool so Gemini has a focused set to rank.

GET https://YOUR_STORE.myshopify.com/admin/api/2026-04/products.json?product_type={{ encodeURIComponent($json.product.product_type) }}&status=active&limit=15

4 Build candidates (Code)

Add a Code node to turn the raw product payload into a tidy list. It strips each product down to the fields Gemini needs, drops the item that was just purchased, and carries the customer details forward.

const purchasedId = $('Shopify Trigger').item.json.line_items[0].product_id;
const products = $json.products || [];

const candidates = products
  .filter(p => p.id !== purchasedId)
  .slice(0, 12)
  .map(p => ({
    title: p.title,
    handle: p.handle,
    price: p.variants?.[0]?.price || "",
    type: p.product_type
  }));

const c = $('Shopify Trigger').item.json.customer;

return [{ json: {
  firstName: c.first_name,
  email: c.email,
  purchased: $('Shopify Trigger').item.json.line_items[0].title,
  candidates
} }];

5 Gemini picks three (HTTP Request)

This is where the AI earns its keep. Add an HTTP Request node with the POST method pointing at the Gemini endpoint. Set the body type to JSON and paste a JSON body that includes the candidate list and a strict instruction. Attach your Gemini key as an HTTP Header Auth credential using the header x-goog-api-key.

POST https://generativelanguage.googleapis.com/v1beta/models/gemini-2.5-flash:generateContent

{
  "contents": [{
    "parts": [{
      "text": "The customer bought: {{ $json.purchased }}. From ONLY this JSON list of products, choose the 3 that best complement the purchase. Never invent products. Return JSON array of {title, handle, reason}. Products: {{ JSON.stringify($json.candidates) }}"
    }]
  }],
  "generationConfig": { "responseMimeType": "application/json", "temperature": 0.4 }
}

6 Build the email (Code)

Gemini returns its answer nested inside the API response. This Code node digs it out, parses it, and assembles simple product cards into an HTML email body.

const raw = $json.candidates[0].content.parts[0].text;
const picks = JSON.parse(raw);
const store = "https://your-store.com/products/";

const cards = picks.map(p =>
  `<p><a href="${store}${p.handle}">${p.title}</a> - ${p.reason}</p>`
).join("");

const first = $('Build candidates').item.json.firstName;

return [{ json: {
  to: $('Build candidates').item.json.email,
  subject: `${first}, three things that pair with your order`,
  html: `<p>Hi ${first},</p><p>Thanks for your order. You might also like:</p>${cards}`
} }];

7 Send with Gmail

Finish with a Gmail node set to Send. Map To to {{ $json.to }}, Subject to {{ $json.subject }}, and the message to {{ $json.html }} with the email type set to HTML. Save the workflow and switch it on.

Common mistakes

Cost at realistic volume

Take a store doing 600 orders a month. That is 600 recommendation emails, each making one Gemini call on gemini-2.5-flash. The Gemini free tier comfortably covers that volume, so the AI cost is zero. Self-hosted n8n is free and one order triggers a handful of lightweight executions. Gmail sends within its normal daily limits at this scale.

Compare that to a paid recommendation app charging a monthly fee plus a slice of attributed revenue, and the workflow pays for itself on the first recovered add-on sale.

Frequently asked questions

Related guides

• Shopify post-purchase follow-up email with n8n
• Shopify customer win-back email with n8n
• Shopify repeat customer reward email with n8n
• Browse every store recipe in the Shopify automation category.

A Shopify order status lookup automation in n8n turns the endless stream of where-is-my-order emails into instant, hands-off replies. A customer submits their order number and email on a simple form, n8n queries the Shopify Admin API, and within seconds they receive a message with the exact fulfillment status and live tracking link. No support agent, no copy-pasting tracking numbers, and your inbox is freed for real problems.

Prefer to skip the setup? Grab the ready-made template → and be answering order status requests automatically in under 10 minutes.

What it does

Where-is-my-order requests, often shortened to WISMO, are the single most common message a Shopify store receives. Industry surveys put them at 40 to 60 percent of all support tickets, and every one of them has the same answer already sitting in your Shopify admin. Answering them by hand is pure repetition: open the order, read the fulfillment status, copy the tracking link, paste it into a reply.

This workflow removes that loop entirely. It is a reactive lookup, which makes it different from a shipping confirmation email that fires once when an order ships. Here the customer asks at any moment, and the automation answers on demand with whatever the current status is. It sits neatly alongside your other Shopify n8n automations as the front line of self-service support.

┌──────────────────────────────────────────────────────────────┐
│  SHOPIFY ORDER STATUS LOOKUP (WISMO AUTO-REPLY)               │
│                                                              │
│  [Lookup Form]                                               │
│       │  order # + email                                     │
│       ▼                                                      │
│  [Webhook] → [Shopify Admin API lookup] → [Order found?]     │
│                                              │        │       │
│                                     yes ◄────┘        └──► no │
│                                      ▼                    ▼   │
│                          [Build status reply]     [Email:    │
│                                      ▼             not found] │
│                          [Email customer status]             │
│                                      ▼                        │
│                          [Telegram ping to merchant]         │
└──────────────────────────────────────────────────────────────┘
  

Why it beats the default

The default Shopify experience does give buyers an order status page and shipping emails. So why do they still email you? Because they lost the email, the link expired from their point of view, or they simply want a human to confirm. The out-of-the-box tools are passive; they wait to be found. This workflow is active: the moment a customer reaches out, they get a personal reply with the live answer.

Compared to a paid help-desk app with a WISMO add-on, the n8n version costs nothing per ticket and stays entirely under your control. You decide the wording, the branding, and which channel the reply goes out on. And because it reads directly from the Shopify Admin API at request time, the status is never stale, unlike a cached export or a nightly sync.

What you need

• A Shopify store with Admin API access. If you have not connected Shopify to n8n yet, follow the 2026 Shopify to n8n connection guide first, it uses the current Dev Dashboard method to create your access token.
• An n8n instance (cloud or self-hosted), version 1.0 or later.
• A Gmail account (or Outlook / SMTP) to send the reply from.
• A Telegram bot and chat ID for the optional merchant ping. This is a nice-to-have, not required.
• A simple lookup form on your store that POSTs the order number and email to the n8n webhook. A plain HTML form or any form app that can send a webhook works.

Estimated build time: 30 to 45 minutes from scratch, or under 10 minutes with the template.

Node-by-node list

Seven nodes, one clean branch. Here is the full map before we build it:

Step-by-step build

1 Where Is My Order? (Webhook)

This node is the entry point. It gives you a URL that your lookup form posts to.

1. Add a Webhook node and set the HTTP Method to POST.
2. Set a path such as order-status.
3. Set Respond to Immediately so the form gets a fast acknowledgement while the rest of the flow runs.
4. Point your store form at the production webhook URL, sending two fields: order_number and email.

After a submission, the data arriving looks like this:

{
  "order_number": "1042",
  "email": "james.carter@gmail.com"
}

2 Look Up Order (HTTP Request)

This node calls the Shopify Admin API and asks for the order by its name.

1. Add an HTTP Request node, Method GET.
2. Set the URL to your store’s orders endpoint on API version 2026-04:
   
   https://YOUR_STORE.myshopify.com/admin/api/2026-04/orders.json
3. Turn on Send Query Parameters and add:
   • name = ={{ $json.order_number }}
   • status = any
   • fields = name,email,financial_status,fulfillment_status,fulfillments,customer
4. Under Authentication, choose Generic Credential Type → Header Auth and set the header name to X-Shopify-Access-Token with your Admin API token as the value.

Shopify returns an orders array. A matched order carries everything you need:

{
  "orders": [
    {
      "name": "#1042",
      "email": "james.carter@gmail.com",
      "financial_status": "paid",
      "fulfillment_status": "fulfilled",
      "fulfillments": [
        { "tracking_number": "9400111899223197428490",
          "tracking_url": "https://tools.usps.com/go/TrackConfirmAction?tLabels=9400111899223197428490" }
      ],
      "customer": { "first_name": "James" }
    }
  ]
}

3 Order Found? (IF)

This node splits the flow depending on whether Shopify returned a match.

1. Add an IF node.
2. Create one condition. Left value: ={{ $json.orders.length }}, type Number.
3. Operation: is greater than. Right value: 0.

The true output goes to Build Status Reply. The false output goes to Email Not Found.

4 Build Status Reply (Edit Fields)

This node pulls the raw Shopify response into a handful of clean, named fields your email can reference.

1. Add an Edit Fields (Set) node on the true branch.
2. Add these string assignments:
   • first_name = ={{ $json.orders[0].customer.first_name }}
   • order_name = ={{ $json.orders[0].name }}
   • status = ={{ $json.orders[0].fulfillment_status || "unfulfilled" }}
   • tracking_url = ={{ $json.orders[0].fulfillments[0]?.tracking_url || "" }}

The result is a tidy object that is easy to drop into an email template:

{
  "first_name": "James",
  "order_name": "#1042",
  "status": "fulfilled",
  "tracking_url": "https://tools.usps.com/go/TrackConfirmAction?tLabels=9400111899223197428490"
}

5 Email Order Status (Gmail)

This node sends the customer their answer.

1. Add a Gmail node, operation Send.
2. To: ={{ $('Where Is My Order?').item.json.email }}
3. Subject: Your order {{ $json.order_name }} status
4. Message body, for example:

Hi {{ $json.first_name }},

Here is the latest on order {{ $json.order_name }}:

Status: {{ $json.status }}
Tracking: {{ $json.tracking_url }}

Thanks for shopping with us!

6 Ping Merchant (Telegram, optional)

A quiet log so you can see the automation working.

1. Add a Telegram node, operation Send Message.
2. Chat ID: your YOUR_TELEGRAM_CHAT_ID.
3. Text: WISMO answered for {{ $json.order_name }} ({{ $json.status }}).

7 Email Not Found (Gmail)

On the false branch, reassure the customer rather than leaving them with silence.

1. Add a second Gmail node, operation Send.
2. To: ={{ $('Where Is My Order?').item.json.email }}
3. Body: tell them you could not match that order number and a team member will follow up, and ask them to double-check the number from their confirmation email.

Common mistakes

Cost at realistic volume

The appeal of this build is that it runs on tools you already pay for, or free tiers. Assume a store fielding 600 WISMO requests a month, a busy small brand.

Against a help-desk app that charges per resolved ticket, answering 600 requests automatically each month is the difference between a recurring bill and effectively zero. The time saved is the bigger prize: at two minutes of manual handling per ticket, 600 lookups is 20 hours a month you get back.

FAQ

Related guides

• Shopify shipping confirmation email with tracking in n8n
• Build a Shopify AI customer support chatbot with n8n
• Send Shopify alerts to Telegram with n8n
• Browse every store automation in the Shopify category.

This shopify sales tax report automation n8n build runs on the first of every month, pulls the previous month’s orders from the Shopify Admin API, sums the tax you collected by state and jurisdiction, writes a clean summary row to Google Sheets, and emails you the totals. No paid tax app, no CSV exports, no manual pivot tables. You keep a permanent audit trail and hand your accountant a tidy sheet instead of a raw order dump.

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

What it does

Every Shopify store collects sales tax, and every store owner eventually has to answer a boring but unavoidable question: how much tax did I actually collect last month, and where? Shopify shows you a total in the admin, but the moment you need it broken down by state, county, or tax name for a filing, you are back to exporting orders and building a spreadsheet by hand.

This workflow removes that chore. On a monthly schedule it reads your orders through the n8n Shopify automation pattern, then does three things:

• Adds up total collected tax, subtotal, and gross sales for the month.
• Breaks that tax down by jurisdiction using each order’s tax_lines, so “California State Tax” and “Los Angeles County” appear as separate lines.
• Saves the summary to a Google Sheet and emails it to you, so the number is filed before you even open your inbox.

The output is the sheet a bookkeeper actually wants: one row per month, tax grouped by name, sales grouped by currency, and a running history you can hand over at quarter end.

Why it beats the default

Shopify’s built-in reports give you a single tax figure and a finance summary, but three things push store owners toward automation.

First, the native breakdown is shallow. You can see total tax, but pulling collected tax per jurisdiction across a full month still means an export and a pivot table. If you sell into several states with economic nexus, that manual step happens every single month.

Second, the manual export has no memory. Once you close the spreadsheet, nothing is archived in a consistent place. Six months later, when you reconcile or an accountant asks for March, you rebuild it from scratch.

Third, paid tax-reporting apps solve this but add a recurring bill and yet another dashboard to log into. For a store that just needs a monthly collected-tax summary for filing prep, that is more tool than the job requires.

The n8n version sits in the middle: it reads the same authoritative order data Shopify already stores, runs on your schedule, and drops a permanent record into a sheet you own. No per-order fee, no vendor lock-in.

What you need

• A running n8n instance, either n8n Cloud or self-hosted.
• A Shopify custom app access token created through the 2026 Shopify Dev Dashboard, with read_orders scope. If you have not connected Shopify to n8n yet, follow how to connect Shopify to n8n in 2026 first.
• A Google account for Google Sheets and Gmail (both free tiers are plenty).
• One blank Google Sheet with a header row to receive the monthly summaries.

Build time is roughly 30 to 40 minutes from scratch, or under 10 minutes if you import the template and paste in your credentials.

Node-by-node list

The workflow is a straight line, no branches. Six nodes, one authoritative data source.

┌────────────────────────────────────────────────────────────────┐
│  SHOPIFY MONTHLY SALES TAX REPORT                              │
│                                                                │
│  [Schedule Trigger]                                            │
│        ↓                                                        │
│  [Build Date Range] (Code)                                     │
│        ↓                                                        │
│  [Get Orders] (HTTP Request, paginated)                        │
│        ↓                                                        │
│  [Aggregate Tax] (Code)                                        │
│        ↓                                                        │
│  [Append to Sheet] (Google Sheets)   →   [Email Report] (Gmail)│
└────────────────────────────────────────────────────────────────┘

Step-by-step build

1 Schedule Trigger

Add a Schedule Trigger node. Set the rule to a Months interval, trigger at day of month 1, hour 6. That runs the report early on the first day of each month, covering the full month that just ended.

2 Build Date Range (Code)

Add a Code node to compute last month’s window. This keeps the workflow self-adjusting so you never hardcode dates.

const now = new Date();
const firstThisMonth = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1));
const firstLastMonth = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth() - 1, 1));

return [{
  json: {
    created_at_min: firstLastMonth.toISOString(),
    created_at_max: firstThisMonth.toISOString(),
    label: firstLastMonth.toISOString().slice(0, 7) // e.g. "2026-06"
  }
}];

3 Get Orders (HTTP Request)

Add an HTTP Request node. Use GET against the Admin API orders endpoint and attach your Shopify token as a Header Auth credential named X-Shopify-Access-Token.

• URL: https://YOUR_STORE.myshopify.com/admin/api/2026-04/orders.json
• Query parameters: status=any, created_at_min={{ $json.created_at_min }}, created_at_max={{ $json.created_at_max }}, limit=250, and fields=id,created_at,currency,subtotal_price,total_price,total_tax,tax_lines.
• Turn Pagination on. Set the mode to follow the response’s Link header so n8n walks every page until Shopify stops returning a next link.

4 Aggregate Tax (Code)

This is the heart of the workflow. Add a Code node in “Run once for all items” mode. It walks every order, sums the money, and groups collected tax by the jurisdiction name Shopify records in tax_lines.

const orders = $input.all().map(i => i.json);
const byJurisdiction = {};
const byCurrency = {};
let totalTax = 0, orderCount = 0;

for (const o of orders) {
  orderCount++;
  const cur = o.currency || 'USD';
  byCurrency[cur] = byCurrency[cur] || { subtotal: 0, gross: 0, tax: 0 };
  byCurrency[cur].subtotal += parseFloat(o.subtotal_price || 0);
  byCurrency[cur].gross    += parseFloat(o.total_price || 0);
  byCurrency[cur].tax      += parseFloat(o.total_tax || 0);
  totalTax += parseFloat(o.total_tax || 0);

  for (const t of (o.tax_lines || [])) {
    const key = t.title || 'Unnamed tax';
    byJurisdiction[key] = (byJurisdiction[key] || 0) + parseFloat(t.price || 0);
  }
}

const label = $('Build Date Range').first().json.label;

return [{
  json: {
    month: label,
    order_count: orderCount,
    total_tax_collected: Number(totalTax.toFixed(2)),
    tax_by_jurisdiction: byJurisdiction,
    sales_by_currency: byCurrency,
    jurisdiction_summary: Object.entries(byJurisdiction)
      .map(([k, v]) => `${k}: ${v.toFixed(2)}`).join(' | ')
  }
}];

After this node one clean item looks like:

{
  "month": "2026-06",
  "order_count": 214,
  "total_tax_collected": 1873.44,
  "jurisdiction_summary": "California State Tax: 902.10 | Los Angeles County: 311.20 | Texas State Tax: 660.14"
}

5 Append to Sheet (Google Sheets)

Add a Google Sheets node set to the Append operation. Pick your spreadsheet and sheet, then map the columns: Month, Orders, Total Tax, and Jurisdiction Breakdown. Each monthly run adds exactly one row, so the sheet becomes a year-at-a-glance tax ledger.

6 Email Report (Gmail)

Add a Gmail node with the Send operation. Address it to yourself or your bookkeeper, subject Sales tax report {{ $json.month }}, and drop the total plus the jurisdiction summary into the body. Now the number reaches you without opening n8n or Shopify.

Common mistakes

• Summing total_tax and also summing tax_lines into the same total. They describe the same money at different granularity. Use the order-level total_tax for the grand total and tax_lines only for the per-jurisdiction breakdown.
• Leaving pagination off. Without it you only get the first 250 orders and every busy month silently under-reports. Always confirm the Link-header pagination is active.
• Using status=open instead of status=any. Archived and cancelled orders still carry collected tax that belongs in a reconciliation, so any is the safe default.
• Running the schedule against the wrong timezone, which shifts the month boundary and double-counts or drops a day’s orders.
• Treating the output as owed tax. It is collected tax. Owed tax depends on nexus rules your accountant applies on top of this data.

Cost at realistic volume

The whole build runs on free infrastructure. Here is the monthly math for a store doing a few hundred orders.

Even a store pushing several thousand orders a month stays free: pagination just adds a handful of API calls, and you are still writing a single summary row. Compare that to a paid tax-reporting app billing monthly, and the automation pays for itself immediately.

Frequently asked questions

Related guides

• All Shopify automation guides
• The complete n8n Shopify automation hub
• How to connect Shopify to n8n in 2026
• Shopify refund tracker in Google Sheets
• Shopify weekly sales PDF report

Shopify store backup automation with n8n saves a nightly JSON snapshot of your products, orders, and customers to Google Drive, then logs each run to a Google Sheet and emails you a summary. It replaces backup apps that charge a monthly fee for the same data your store already exposes through the Admin API. You keep the files, the schedule, and the retention rules. Building it from scratch takes about 40 minutes.

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

What it does

Shopify keeps your live data, but it does not hand you a full historical backup you control. If a bulk edit goes wrong, an app corrupts your catalog, or you ever need last month’s customer list, the platform will not give you a point-in-time copy. This workflow fills that gap.

Every night, n8n reads three datasets from your store through the Admin API: the full product catalog, all orders, and all customers. It bundles them into one dated JSON file, uploads that file to a Google Drive folder, appends a row to a running log sheet, and sends you a short confirmation email. The next morning you have a fresh, timestamped copy of everything, sitting in storage you own.

This is part of the broader pattern of connecting your store to a workflow engine. If you are new to it, start with our guide to n8n Shopify automation and come back here.

Why it beats the default

Most merchants handle backups in one of two ways, and both leave gaps.

The first is a paid backup app from the Shopify App Store. These work, but they charge a recurring fee that scales with your order volume, and your snapshots live inside a vendor’s account rather than yours. If that vendor changes pricing or shuts down, your safety net goes with it.

The second is manual CSV exports from the admin. This is free but partial. You export products one day, forget orders the next, and end up with a scattered pile of files that nobody dated properly. It relies on a human remembering to do a boring task on time, which is exactly the kind of task automation exists to remove.

The n8n version gives you the full three-dataset snapshot, on a fixed schedule, written to your own Drive, with a log you can audit. There is no per-record pricing, and you decide how long to keep each copy.

What you need

• An n8n instance, either n8n Cloud or a self-hosted install.
• A Shopify custom app access token with read scopes for products, orders, and customers. Follow our walkthrough on how to connect Shopify to n8n in 2026, which uses the current Dev Dashboard method and a modern Admin API version (2026-04).
• A Google account for Drive, Sheets, and Gmail, connected to n8n with OAuth.
• One Google Drive folder to hold the snapshots and one Google Sheet for the run log.

Estimated build time is 30 to 45 minutes from scratch, or under 10 minutes with the template.

How it works

The workflow fans out to three Shopify reads in parallel, waits for all of them to finish, then assembles and stores the snapshot.

┌──────────────────────────────────────────────────────────────┐
│  SHOPIFY NIGHTLY BACKUP                                       │
│                                                              │
│  [Schedule 02:00] ─┬─→ [Get all products] ─┐                 │
│                    ├─→ [Get all orders]   ─┤                 │
│                    └─→ [Get all customers]─┘                 │
│                                    ↓                         │
│                               [Merge (3)]                    │
│                                    ↓                         │
│                          [Build snapshot file]               │
│                                    ↓                         │
│              [Upload to Drive] → [Log to Sheet] → [Email]     │
└──────────────────────────────────────────────────────────────┘
  

Node-by-node list

Step-by-step build

1 Schedule the run

Add a Schedule Trigger node. Set the rule to a daily interval and pick a quiet hour such as 02:00. Overnight runs keep the backup away from busy checkout traffic and the daily API limits that come with it.

2 Read products, orders, and customers

Add three Shopify nodes, each connected directly to the Schedule Trigger so they run in parallel from a single trigger item. Configure them like this:

1. Node one: resource Product, operation Get Many, and turn on Return All so it pages through the entire catalog.
2. Node two: resource Order, operation Get Many, Return All on, and under options set Status to Any so cancelled and archived orders are included.
3. Node three: resource Customer, operation Get Many, Return All on.

Attach your Shopify Access Token credential to all three. Each node runs once and returns its full dataset.

3 Merge the three branches

Add a Merge node and set the number of inputs to 3. Connect each Shopify node to a separate input. Its only job is to pause the flow until all three reads have finished, so the next node does not run before the data is ready.

4 Build the snapshot file

Add a Code node running once for all items. It pulls each dataset by node name, wraps them in one object with a timestamp and record counts, and returns the result as an attached JSON file.

const products  = $('Get all products').all().map(i => i.json);
const orders    = $('Get all orders').all().map(i => i.json);
const customers = $('Get all customers').all().map(i => i.json);

const stamp = $now.format('yyyy-LL-dd');
const fileName = `shopify-backup-${stamp}.json`;

const snapshot = {
  generated_at: $now.toISO(),
  store: 'your-store.myshopify.com',
  counts: {
    products:  products.length,
    orders:    orders.length,
    customers: customers.length
  },
  products, orders, customers
};

return [{
  json: {
    file_name: fileName,
    date: stamp,
    products: products.length,
    orders: orders.length,
    customers: customers.length
  },
  binary: {
    data: {
      data: Buffer.from(JSON.stringify(snapshot, null, 2)).toString('base64'),
      mimeType: 'application/json',
      fileName
    }
  }
}];

After this node, one item carries both the plain counts and the ready-to-upload file:

{
  "file_name": "shopify-backup-2026-07-11.json",
  "date": "2026-07-11",
  "products": 214,
  "orders": 1863,
  "customers": 1592
}

5 Upload to Google Drive

Add a Google Drive node with operation Upload. Set the input binary field to data, and choose the destination folder you created for backups. Use the file name from the previous node so every upload keeps its date.

1. Operation: Upload.
2. File Name: ={{ $json.file_name }}
3. Input Binary Field: data
4. Parent Folder: select your Shopify Backups folder.

6 Log the run to Google Sheets

Add a Google Sheets node with operation Append. Point it at a log sheet and map the columns to the fields from the Code node. This gives you an audit trail you can scan at a glance.

7 Email the summary

Add a Gmail node with operation Send. Send yourself a short message so you know the backup ran without opening Drive.

Subject: Shopify backup complete — {{ $json.date }}

Products: {{ $json.products }}
Orders:   {{ $json.orders }}
Customers:{{ $json.customers }}
File:     {{ $json.file_name }}

The data structure

The Google Sheet log is deliberately simple. One row per night is enough to prove the backup ran and to spot a sudden drop in record counts that might signal a problem upstream.

Common mistakes

• Leaving Return All off on the Shopify nodes, which caps each dataset at 50 records and produces a backup that looks fine but is missing most of the store.
• Chaining the three Shopify reads one after another instead of running them in parallel into a Merge. Chaining makes the second read run once per record from the first, which multiplies API calls and can trip rate limits.
• Forgetting to set the Input Binary Field on the Drive node to data, which uploads an empty or wrong file.
• A mismatch between the Sheet header row and the mapped fields, which writes blank cells.
• Running on UTC when you meant local time, so the 02:00 backup lands in the middle of your business day.
• Granting the access token read scope for only one resource. It needs read access to products, orders, and customers, or the missing branch returns an error.

Cost at realistic volume

Take a store with 200 products, 1,800 orders, and 1,600 customers running one backup a night. Every service in the workflow sits inside a free tier at that scale.

A daily snapshot of a few megabytes adds up to roughly a gigabyte a year, well within the free Drive quota. Compared with a backup app that bills every month whether or not you ever restore, the running cost here rounds to zero.

Frequently asked questions

Related guides

• Connect Shopify to n8n in 2026, the credential setup this workflow depends on.
• Send new Shopify orders to Google Sheets for a live running order log.
• Bulk update Shopify prices from Google Sheets, a good reason to keep a backup handy.
• Browse every guide in the Shopify automation category.