Shopify & E-commerce

Shopify bulk product upload from CSV with n8n turns a Google Sheet or exported CSV into live Shopify products, one row at a time, with no paid importer app. You map spreadsheet columns to product fields, loop through each row, and POST to the Shopify Admin API on a rate-safe delay. This guide builds the whole flow from scratch and hands you a template you can import in minutes.

If you have ever pasted 200 rows into Shopify’s native CSV importer and watched it silently drop half of them, you know the pain. The built-in importer is rigid about column names, gives you almost no error feedback, and cannot touch anything Shopify did not plan for. This n8n workflow reads your spreadsheet, builds a clean product payload per row, and creates each product through the Admin API so you see exactly what succeeded and what did not.

Prefer to skip the build? Grab the ready-made template and connect it to your store in under ten minutes.

What it does

The workflow reads a list of products from a Google Sheet (or a CSV, with one small swap), then walks through the rows one by one and creates each product in your Shopify store. Here is the flow from the merchant’s point of view:

1. You fill a Google Sheet with one product per row, using columns like title, price, SKU and vendor.
2. You click Execute in n8n, or wire the workflow to a schedule so it runs on its own.
3. n8n reads every row and loops through them at a pace Shopify is happy with.
4. Each row becomes a real product in your catalog, complete with a variant, price and SKU.
5. You watch the run finish in the n8n execution log, row by row, with a clear pass or fail on each one.

┌──────────────────────────────────────────────────────────────────┐
│  BULK PRODUCT UPLOAD                                               │
│                                                                   │
│  [Execute] → [Read rows] → [Loop Over Items]                      │
│                                 │  (each row)                      │
│                                 ▼                                  │
│                          [Build payload] → [Create product]       │
│                                 ▲                    │             │
│                                 └──── [Wait 0.6s] ◀──┘             │
│                                 │  (done)                          │
│                                 ▼                                  │
│                          [All products created]                   │
└──────────────────────────────────────────────────────────────────┘
  

Why it beats the default

Shopify already ships a CSV importer, so why build this? Because the native tool trades control for convenience, and a growing store usually needs the control back.

The real win is that the upload becomes a step you own. Once the rows flow through n8n you can bolt on a Google Gemini node to write descriptions, a tagging step, or a Slack ping when the batch finishes, all without leaving the workflow. For the bigger picture of what else n8n can drive on a store, see the n8n Shopify automation hub.

What you need

• A Shopify store with a custom app created in the 2026 Shopify Dev Dashboard, giving you an Admin API access token with write_products scope.
• An n8n instance, cloud or self-hosted, on version 1.0 or newer.
• A Google account with a Sheet of products, or a CSV file if you prefer.
• About 30 minutes to build from scratch, or 10 minutes with the template.

If you have not connected Shopify to n8n yet, follow connect Shopify to n8n (2026 method) first. It walks through the Dev Dashboard custom app and the Admin API token this workflow needs. The old admin custom-app screen is gone, so ignore any tutorial that still points there.

The nodes, one by one

The whole flow is seven nodes. Nothing exotic, and no Code node required.

Build it step by step

1 When clicking Execute (Manual Trigger)

Add a Manual Trigger node. It gives you a button to run the upload on demand while you test. Later you can swap it for a Schedule Trigger if you want the sheet drained automatically every night.

2 Read product rows (Google Sheets)

Add a Google Sheets node, set the operation to Get Row(s), and point it at your document and sheet tab. Connect your Google credential. When it runs, each row comes back as one item. A clean source sheet looks like this:

3 Loop Over Items (Split In Batches)

Add the Loop Over Items node and set Batch Size to 1. This is the piece that keeps Shopify happy. Instead of firing 200 create calls at once and hitting a rate-limit wall, the loop hands the workflow a single product, waits for it to finish, then serves the next.

4 Build product payload (Edit Fields)

Add an Edit Fields (Set) node to translate spreadsheet columns into the exact field names Shopify expects. Create these assignments, each with the matching type:

title            (string)  =  {{ $json.Title }}
body_html        (string)  =  {{ $json.Body }}
vendor           (string)  =  {{ $json.Vendor }}
product_type     (string)  =  {{ $json.Type }}
tags             (string)  =  {{ $json.Tags }}
status           (string)  =  {{ $json.Status }}
price            (string)  =  {{ $json.Price }}
sku              (string)  =  {{ $json.SKU }}

5 Create product (HTTP Request)

Add an HTTP Request node. This is the node that talks to Shopify. Configure it like this:

1. Method: POST
2. URL: https://YOUR-STORE.myshopify.com/admin/api/2026-04/products.json
3. Authentication: Generic Credential Type, then Header Auth. Set the header name to X-Shopify-Access-Token and the value to your Admin API access token.
4. Send Body: on. Body Content Type: JSON. Specify Body: Using JSON.
5. Paste this into the JSON body field as an expression:

{
  "product": {
    "title": "{{ $json.title }}",
    "body_html": "{{ $json.body_html }}",
    "vendor": "{{ $json.vendor }}",
    "product_type": "{{ $json.product_type }}",
    "tags": "{{ $json.tags }}",
    "status": "{{ $json.status }}",
    "variants": [
      { "price": "{{ $json.price }}", "sku": "{{ $json.sku }}" }
    ]
  }
}

6 Wait 0.6s (Wait)

Add a Wait node set to 0.6 seconds. Shopify’s REST Admin API allows two requests per second on standard plans, so a pause a little over half a second keeps you safely under the ceiling even with retries. Connect the Wait node back into the Loop Over Items node so the loop moves to the next row.

7 All products created (No Operation)

Connect the loop’s done output to a No Operation node named something clear like All products created. It does nothing functional, but it gives the workflow a tidy end point and a spot to add a Slack or Gmail summary later.

Common mistakes

• Leaving Batch Size at its default instead of 1, which fires every row at once and trips Shopify’s rate limit with a wave of 429 errors.
• Wiring the Wait node forward instead of back into the loop, so the workflow processes one product and stops.
• Expecting stock to appear. The create call ignores inventory quantity in current API versions. Stock is set on the inventory_levels endpoint after the product exists.
• Using the old admin custom-app token flow. Create the app in the 2026 Dev Dashboard and use the X-Shopify-Access-Token header instead.
• Sending the body as a raw object or a hand-built string. Use Specify Body: Using JSON so n8n serializes it correctly.
• Re-running on the same sheet and creating duplicates. Add a Status column and an IF node to skip rows already marked Done.

Cost at realistic volume

This is one of those rare automations that costs essentially nothing to run.

At two requests per second, 500 products upload in roughly five minutes and 5,000 in under an hour. Compared with a paid bulk-import app charging a monthly fee, the running cost here rounds to zero.

Get the ready-to-import template

You now know how every node fits together. If you would rather not wire it by hand, the template drops the whole flow onto your canvas ready to connect.

Frequently asked questions

Related guides

• Connect Shopify to n8n (2026 method), the token setup this workflow depends on.
• Shopify AI product description generator with n8n, to write the copy before you upload.
• Shopify low stock alert with n8n, to watch inventory once products are live.
• Browse every store automation in the Shopify guides category.

If you run two Shopify stores that sell the same products, a wholesale storefront and a retail one, or a US and an EU store, you already know the pain: a unit sells on one store and the other keeps advertising stock it no longer has. This guide shows you how to sync inventory between two Shopify stores with n8n, so every sale or manual stock edit on one store updates the matching product on the other in seconds. You will build a free, real-time workflow that catches each inventory change, matches products by SKU, and writes the new quantity to your second store. No paid multi-store app, no nightly spreadsheet reconciliation.

Prefer to skip the setup? Have us build and install it for you → and be live in a day.

What it does

The workflow listens for stock changes on your primary store and mirrors them onto your second store. When a variant’s quantity changes, Shopify sends an inventory_levels/update webhook to n8n. The workflow reads which item changed, looks up that item’s SKU, then searches the second store for the variant carrying the same SKU and sets its available quantity to match.

Here is the full path a single change travels:

┌──────────────────────────────────────────────────────────────────┐
│  SYNC INVENTORY BETWEEN TWO SHOPIFY STORES                         │
│                                                                    │
│  Store A sells 1 unit                                              │
│        │                                                           │
│        ▼                                                           │
│  [Webhook: inventory_levels/update]                               │
│        │  { inventory_item_id, available }                        │
│        ▼                                                           │
│  [Get SKU from Store A]  ──►  sku: "TSHIRT-BLK-M"                  │
│        │                                                           │
│        ▼                                                           │
│  [Has SKU?] ──► yes                                               │
│        │                                                           │
│        ▼                                                           │
│  [Find variant in Store B by SKU]  ──►  inventoryItem id          │
│        │                                                           │
│        ▼                                                           │
│  [Variant exists?] ──► yes                                        │
│        │                                                           │
│        ▼                                                           │
│  [Set quantity in Store B]  ──►  available = new stock            │
│        │                                                           │
│        ▼                                                           │
│  [Log to Slack]                                                   │
└──────────────────────────────────────────────────────────────────┘
  

Why it beats the default

The two usual answers to multi-store stock are a paid sync app or a manual export. Dedicated apps such as the popular inventory-sync tools charge a monthly fee that climbs with your product count and often bill per synced SKU. A CSV export and re-import is free but slow, error-prone, and always out of date the moment a customer checks out.

This n8n build gives you a middle path that most merchants never realize is available:

• Real time. Stock moves within seconds of the sale, not on a nightly batch.
• Flat cost. You pay for one n8n instance regardless of whether you sync 50 SKUs or 5,000.
• SKU based, so it works even when the two stores have different product IDs, handles, and themes.
• Fully yours. The logic sits in your own workflow, so you can add rules, buffers, or a Slack log without waiting on an app’s feature roadmap.

It slots neatly into a wider stack too. If you already run any of our other n8n Shopify automations, this uses the same connection and the same Admin API you have already set up.

What you need

• Two Shopify stores where you are the admin on both.
• An n8n instance, either n8n Cloud or a self-hosted install.
• An Admin API access token on each store, created with the 2026 Shopify Dev Dashboard method. If you have not connected Shopify to n8n yet, follow how to connect Shopify to n8n in 2026 first, once per store.
• The read_inventory and write_inventory access scopes on both tokens, plus read_products.
• Matching SKUs. Every variant you want to keep in sync must carry the identical SKU string on both stores. This is the join key, so it has to be exact.
• The location ID of the destination store, which you will drop into a config node once.

All API calls in this guide use Admin API version 2026-04. Build time is around 40 minutes from scratch, or a few minutes if you import the ready-made template.

Node-by-node list

Eight nodes carry a change from the first store to the second. Here is the whole map before we build it.

Step-by-step build

1 Store A inventory webhook (Webhook)

This node is the entry point. Add a Webhook node, set the method to POST, and give it a path like store-a-inventory. Copy the production URL n8n shows you. Then register it on your source store by creating a webhook subscription for the inventory_levels/update topic pointing at that URL. When a variant’s stock changes, Shopify posts a small payload here.

{
  "inventory_item_id": 44827362891,
  "location_id": 71034829,
  "available": 7,
  "updated_at": "2026-07-06T14:32:08-05:00"
}

2 Config (Set / Edit Fields)

Add a Set node right after the webhook so the store-specific values live in one place. In an Edit Fields node, add three string assignments so future edits never touch the request nodes.

storeADomain     = "acme-wholesale.myshopify.com"
storeBDomain     = "acme-retail.myshopify.com"
storeBLocationId = "gid://shopify/Location/62918342"

3 Get SKU from Store A (HTTP Request)

The webhook tells you which inventory item changed but not its SKU, so fetch it. Use an HTTP Request node with a GET to the source store’s inventory item endpoint.

GET https://{{ $('Config').item.json.storeADomain }}/admin/api/2026-04/inventory_items/{{ $('Store A inventory webhook').item.json.body.inventory_item_id }}.json

Authenticate with a generic header credential that sends X-Shopify-Access-Token set to Store A’s token. The response carries the SKU you will match on.

{
  "inventory_item": {
    "id": 44827362891,
    "sku": "TSHIRT-BLK-M",
    "tracked": true
  }
}

4 Has SKU? (Filter)

Some items have no SKU, and those cannot be matched. Add a Filter node with one condition: {{ $json.inventory_item.sku }} is not empty. Only rows that pass move on, which keeps blank-SKU noise out of the rest of the flow.

5 Find variant in Store B (HTTP Request)

Now search the destination store for the variant that shares this SKU. Use an HTTP Request node with a POST to Store B’s GraphQL endpoint, https://{{ $('Config').item.json.storeBDomain }}/admin/api/2026-04/graphql.json, authenticated with Store B’s token. Set the body type to JSON and send this JSON body.

{
  "query": "query($q: String!) { productVariants(first: 1, query: $q) { edges { node { id sku inventoryItem { id } } } } }",
  "variables": {
    "q": "sku:{{ $('Get SKU from Store A').item.json.inventory_item.sku }}"
  }
}

A match returns the destination variant’s inventory item ID, which is the target for the write.

{
  "data": {
    "productVariants": {
      "edges": [
        { "node": { "id": "gid://shopify/ProductVariant/70051839",
                    "sku": "TSHIRT-BLK-M",
                    "inventoryItem": { "id": "gid://shopify/InventoryItem/58120394" } } }
      ]
    }
  }
}

6 Variant exists? (Filter)

Guard against SKUs that live in one store but not the other. Add a Filter node that continues only when the edges array has a result: {{ $json.data.productVariants.edges[0]?.node?.inventoryItem?.id }} is not empty. If nothing matched, the item is skipped cleanly with no error.

7 Set quantity in Store B (HTTP Request)

This is the write. Use an HTTP Request node with a POST to the same Store B GraphQL endpoint, JSON body type, and the inventorySetQuantities mutation. It sets the destination variant’s available count to whatever Store A now reports.

{
  "query": "mutation($input: InventorySetQuantitiesInput!) { inventorySetQuantities(input: $input) { inventoryAdjustmentGroup { reason } userErrors { field message } } }",
  "variables": {
    "input": {
      "name": "available",
      "reason": "correction",
      "ignoreCompareQuantity": true,
      "quantities": [
        {
          "inventoryItemId": "{{ $('Find variant in Store B').item.json.data.productVariants.edges[0].node.inventoryItem.id }}",
          "locationId": "{{ $('Config').item.json.storeBLocationId }}",
          "quantity": {{ $('Store A inventory webhook').item.json.body.available }}
        }
      ]
    }
  }
}

8 Log to Slack (Slack)

Finish with a Slack node so you have a running record and catch failures fast. Set the resource to message, pick your channel with the channel selector, and post a short line.

Synced {{ $('Get SKU from Store A').item.json.inventory_item.sku }} to {{ $('Store A inventory webhook').item.json.body.available }} units on the retail store.

Prefer email or a spreadsheet log instead? Swap this node for a Gmail node or a Google Sheets append and keep the rest of the flow untouched.

Common mistakes

• SKUs that do not match exactly. A trailing space, a different case, or a missing suffix means the lookup finds nothing. Standardize SKUs across both stores before you switch this on.
• Using the numeric location ID where a GraphQL global ID is required. The inventorySetQuantities mutation wants gid://shopify/Location/…, not the bare number.
• Forgetting write_inventory scope on the destination token. The read side will work and the write will fail with a permissions error in userErrors.
• Untracked inventory. If a variant is not set to track quantity in the destination store, Shopify has nothing to update. Enable inventory tracking on those variants first.
• Building a two-way sync without a loop guard. If both stores write to each other, one change can bounce back and forth. Skip the write when the incoming quantity already equals the destination count.
• Hitting the Admin API rate limit during a bulk edit. If you re-sync hundreds of items at once, add a short wait or batch the calls so you stay under the limit.

Cost at realistic volume

The moving parts here are the two Shopify Admin APIs, which cost nothing beyond your existing plans, and the n8n instance that runs the logic. Say a busy pair of stores sees 500 inventory changes a day. Each change fires three API calls, roughly 1,500 calls a day, well within Shopify’s normal limits.

There is no AI model in this workflow and no per-message billing, so the cost stays flat whether you sync 50 SKUs or 5,000. The savings compared with a per-SKU sync app grow as your catalog does.

FAQ

Related guides

• How to connect Shopify to n8n in 2026, the one-time setup this workflow builds on.
• Shopify low-stock alerts with n8n, to warn you before a synced SKU runs out.
• Send Shopify orders to Google Sheets, a companion logging pattern.
• Browse every build in our Shopify automation guides.

What it does

Every Monday at 8am, this workflow asks Shopify for all orders from the previous seven days, adds up how many units each product sold, and ranks them. The top ten land in a running Google Sheet so you build a week-over-week history, and the same list arrives in your inbox as a clean HTML table. You open your email and immediately know what moved, without logging into the admin or clicking through the Analytics tab.

It is a small piece of the larger picture covered in our n8n Shopify automation guide: instead of pulling reports by hand, you let a scheduled workflow deliver the numbers you actually act on. Best-seller data drives restock decisions, ad budget, and which products deserve a homepage slot, so having it pushed to you beats remembering to go fetch it.

Why it beats the default

Shopify already shows best sellers under Analytics, so why build this? Three reasons.

• It comes to you. A report you have to remember to open is a report you stop reading after week two. Email plus a Sheet means the numbers show up whether or not you log in.
• It builds history you own. The native dashboard is a live view. This workflow appends every week to a Google Sheet, so after a couple of months you can chart trends, spot a product fading, and pivot a table however you like.
• It is yours to shape. Want the top 20, a revenue ranking, only a single collection, or the report sent to three people? Those are one-line edits here. The built-in dashboard gives you none of that control.

The native report is fine for a quick glance. This is for the owner who wants the data delivered, logged, and reshaped on their terms.

What you need

• An n8n instance, cloud or self-hosted. A free self-hosted setup is enough.
• A Shopify store on any paid plan, plus an app access token with read_orders and read_products scopes.
• A Google account for Google Sheets, connected to n8n by OAuth2.
• A Gmail account for the email, also connected by OAuth2.
• A blank Google Sheet with a header row: Week Of, Rank, Product, Variant, Units Sold, Revenue.

Build time: about 35 minutes from scratch, or under 10 minutes with the ready-made template.

Node-by-node list

Six nodes, one clean line with a short branch at the end so the Sheet gets every row while the email gets one message.

┌───────────────────────────────────────────────────────────────┐
│  SHOPIFY WEEKLY BEST SELLERS REPORT                            │
│                                                               │
│  [Schedule Trigger]  weekly, Mon 08:00                        │
│         ↓                                                     │
│  [Shopify: Get Many Orders]  created in last 7 days           │
│         ↓                                                     │
│  [Code: Rank Best Sellers]  aggregate + sort + top 10         │
│         ├──────────────→ [Google Sheets: Append]  all rows    │
│         ↓                                                     │
│  [Limit: Keep 1]  →  [Gmail: Send Report]  one email          │
└───────────────────────────────────────────────────────────────┘
  

1. Schedule Trigger (n8n-nodes-base.scheduleTrigger) — fires weekly, Monday 08:00.
2. Shopify (n8n-nodes-base.shopify) — Get Many orders created in the last 7 days.
3. Code (n8n-nodes-base.code) — ranks products by units sold and builds the report HTML.
4. Google Sheets (n8n-nodes-base.googleSheets) — appends one row per top product.
5. Limit (n8n-nodes-base.limit) — reduces the ranked list to a single item for the email.
6. Gmail (n8n-nodes-base.gmail) — sends the HTML best-sellers report.

Step-by-step build

1 Schedule Trigger

Add a Schedule Trigger. Set the interval field to Weeks, trigger day to Monday, and trigger hour to 8. This gives you a fresh report at the start of every week, covering the seven days that just closed.

2 Shopify — Get Many Orders

Add a Shopify node. Set resource to Order and operation to Get Many. Turn on Return All. Under Options, add Created At Min and set it to an expression that resolves to seven days ago:

={{ $now.minus({ days: 7 }).toISO() }}

Also add the Status option and set it to Any so you capture every order, then let the Code node decide what counts. Each order returned carries a line_items array, which is what we rank on.

3 Code — Rank Best Sellers

Add a Code node (Run Once for All Items, JavaScript). This is the heart of the workflow. It flattens every line item, sums units and revenue per product, sorts, keeps the top ten, and builds one HTML report attached to every row.

// Aggregate best-selling products from the past week's orders
const stats = {};

for (const item of $input.all()) {
  const order = item.json;
  if (order.cancelled_at) continue; // skip cancelled orders
  for (const li of order.line_items || []) {
    const key = li.product_id + '|' + (li.variant_title || '');
    if (!stats[key]) {
      stats[key] = { product: li.title, variant: li.variant_title || '—', unitsSold: 0, revenue: 0 };
    }
    stats[key].unitsSold += li.quantity;
    stats[key].revenue  += li.quantity * parseFloat(li.price);
  }
}

const weekOf = $now.minus({ days: 7 }).toFormat('LLL d')
  + ' – ' + $now.toFormat('LLL d, yyyy');

const ranked = Object.values(stats)
  .sort((a, b) => b.unitsSold - a.unitsSold)
  .slice(0, 10)
  .map((p, i) => ({ rank: i + 1, weekOf, ...p, revenue: Math.round(p.revenue * 100) / 100 }));

const rows = ranked.map(p =>
  `<tr><td>${p.rank}</td><td>${p.product}</td><td>${p.variant}</td>`
  + `<td>${p.unitsSold}</td><td>$${p.revenue.toFixed(2)}</td></tr>`
).join('');

const reportHtml = `<h2>Best sellers — ${weekOf}</h2>`
  + `<table border="1" cellpadding="6" cellspacing="0">`
  + `<tr><th>#</th><th>Product</th><th>Variant</th><th>Units</th><th>Revenue</th></tr>`
  + `${rows}</table>`;

return ranked.map(p => ({ json: { ...p, reportHtml } }));

After this node runs on a sample week, one output item looks like this:

{
  "rank": 1,
  "weekOf": "Jun 23 – Jun 30, 2026",
  "product": "Cedar Wax Melts",
  "variant": "Vanilla Bourbon",
  "unitsSold": 214,
  "revenue": 2461.50,
  "reportHtml": "<h2>Best sellers — Jun 23 ... </table>"
}

4 Google Sheets — Append

Add a Google Sheets node. Set operation to Append, pick your document and sheet, and set mapping to Map Each Column Manually. Map the columns to the fields from the Code node:

Because the Code node returns ten items, this node appends ten rows in one run, one per top product. Over the weeks the sheet becomes your best-seller history.

5 Limit — Keep 1

Connect a second line from the Code node into a Limit node and set Max Items to 1. The email should be a single message, not ten. Because every ranked item carries the identical reportHtml, keeping just the first item still gives you the whole table.

6 Gmail — Send Report

Add a Gmail node, operation Send. Set the recipient to your address, the subject to an expression, and the message to the report HTML with the email type set to HTML:

• Subject: =Best sellers this week {{ $json.weekOf }}
• Message: ={{ $json.reportHtml }}

Save the workflow and toggle it Active. Next Monday at 8am the report lands on its own.

Common mistakes

• Wiring Limit after Google Sheets. The append node’s output does not carry the report HTML, so the email comes out empty. Branch Limit straight off the Code node instead.
• Leaving the timezone on UTC. The schedule then fires at the wrong local hour and Created At Min covers a shifted window. Set the instance timezone once.
• Forgetting read_products scope. Orders return but some fields are thin. Grant both order and product read scopes on the app.
• Counting cancelled orders. Without the cancelled_at skip, a large cancelled order can crown a false best seller. The Code node handles this, so do not remove that line.
• Not turning on Return All. With it off you only get the first page of orders and undercount every product in a busy week.

Cost at realistic volume

This workflow uses no paid AI and no metered messaging, so the running cost is close to zero.

Even at thousands of weekly orders the only variable is how long the Shopify pull takes, which costs you time, not money. Compare that to a paid analytics app charging a monthly fee for a view you can generate yourself.

Frequently asked questions

Related guides

• n8n Shopify automation: the full guide
• Shopify weekly sales PDF report with n8n
• Sync Shopify new orders to Google Sheets
• More Shopify automation guides →

This guide builds a Shopify failed payment recovery email in n8n that watches for orders stuck on payment pending, waits a couple of hours, then emails the customer a friendly nudge to finish paying. It uses a Schedule Trigger, the Shopify Admin API, a Gmail send, and an order tag so nobody gets chased twice. You can have it live in about 35 minutes, and it quietly claws back revenue that would otherwise just sit there unpaid.

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

What it does

Not every Shopify order gets paid the moment it is placed. If your store accepts bank transfers, cash on delivery, manual payment methods, or you invoice bigger customers through draft orders, those orders land in your admin marked Payment pending. The customer meant to pay, then got distracted, and now that order is just sitting there. Multiply it across a month and it adds up to real money you already earned but never collected.

This workflow runs on a timer. Every hour it asks Shopify for open orders that are still pending, keeps only the ones that have been waiting a sensible amount of time, and sends each customer a short reminder email with a link back to their order so they can complete payment. Once an order has been contacted, the workflow tags it inside Shopify so the next run skips it. No spreadsheets to babysit, no double emails, no manual chasing.

It sits naturally alongside the rest of an automated store. If you are building out a stack of these, the n8n Shopify automation hub collects the related order and customer workflows in one place.

Why it beats the default

Shopify will happily show you a pending order in the admin, but it will not chase the customer for you. Out of the box your only options are to manually scan the Orders page and email people one at a time, or to ignore the problem and write the money off. Neither scales past a handful of orders a week.

Paid recovery apps from the Shopify App Store solve it, but they charge a monthly fee or a slice of every order they recover, and they lock the logic inside their dashboard. With n8n you own the workflow end to end. You decide how long to wait, what the email says, and when to stop. There is no per-order cut and no extra subscription, because the same n8n instance can run all of your store automations together.

The tagging step is the part most homegrown attempts miss. Because the reminder writes a tag straight back to the order, the system has a memory. That single detail is what turns a script that spams customers every hour into a tool that contacts each person exactly once.

What you need

• An n8n instance, either n8n Cloud or self-hosted, on version 1.0 or newer.
• A Shopify store with admin API access, so n8n can read orders and write tags.
• A Gmail account connected to n8n for sending the reminder. Outlook or SMTP work just as well.
• At least one payment method that produces pending orders, such as bank deposit, cash on delivery, or draft order invoices.

Build time is roughly 35 minutes from scratch, or under 10 minutes if you import the template and drop in your credentials.

How it works, the big picture

  SHOPIFY FAILED PAYMENT RECOVERY EMAIL

  [Schedule Trigger]  hourly
        |
        v
  [HTTP Request] -- GET pending orders from Shopify
        |
        v
  [Split Out] -- one item per order
        |
        v
  [Filter] -- 2 to 48h old, has email, not yet tagged
        |
        v
  [Gmail] -- send "finish your payment" reminder
        |
        v
  [HTTP Request] -- PUT tag "payment-reminder-sent" on the order
  

Node-by-node list

Six nodes, in a single straight line. Nothing branches, which keeps it easy to reason about.

Step-by-step build

1. Add the Schedule Trigger

Create a new workflow and drop in a Schedule Trigger node. Set it to a fixed interval of every 1 hour. This is the only trigger in the workflow, and it sits at the very start so the run always begins on the timer, never in the middle of the flow.

2. Get pending orders from Shopify

Add an HTTP Request node wired to the trigger. Configure it like this:

1. Method: GET
2. URL: https://YOUR-STORE.myshopify.com/admin/api/2026-04/orders.json
3. Authentication: Header Auth, with header X-Shopify-Access-Token set to your admin API token.
4. Send Query Parameters: on. Add status = open, financial_status = pending, limit = 250, and fields = id,name,email,created_at,order_status_url,tags,total_price,currency.

The response hands back an object with an orders array. A single order looks roughly like this:

{
  "id": 5123456789012,
  "name": "#1042",
  "email": "james.carter@gmail.com",
  "created_at": "2026-06-27T13:10:42-04:00",
  "order_status_url": "https://your-store.myshopify.com/.../orders/abc123",
  "tags": "",
  "total_price": "129.00",
  "currency": "USD"
}

3. Split the orders into single items

Add a Split Out node. Set the field to split out to orders. n8n now emits one item per order, so every node after this point works on a single order at a time instead of one big array.

4. Filter down to orders worth emailing

Add a Filter node with three conditions, all of which must be true. This is where you avoid both nagging people too early and chasing dead orders forever.

1. Older than 2 hours: {{ $now.diff($json.created_at, 'hours') >= 2 }} is true.
2. Younger than 48 hours: {{ $now.diff($json.created_at, 'hours') <= 48 }} is true.
3. Has an email and is not already tagged: {{ $json.email && !$json.tags.includes('payment-reminder-sent') }} is true.

Orders that fail any check drop out silently, which is exactly what you want.

5. Send the reminder with Gmail

Add a Gmail node set to send a message. Map the fields to the current order:

1. To: {{ $json.email }}
2. Subject: Your order {{ $json.name }} is almost done
3. Message: a short, warm note. For example: Hi, we are holding order {{ $json.name }} for you but have not received payment yet. You can review it and finish up here: {{ $json.order_status_url }}. Reply to this email if anything went wrong and we will sort it out.

6. Tag the order so it is only emailed once

Add a final HTTP Request node to write the tag back to Shopify:

1. Method: PUT
2. URL: https://YOUR-STORE.myshopify.com/admin/api/2026-04/orders/{{ $json.id }}.json
3. Authentication: the same Shopify Header Auth credential.
4. Body: set Send Body on, Body Content Type to JSON, then provide the JSON body below.

{
  "order": {
    "id": {{ $json.id }},
    "tags": "{{ $json.tags }}, payment-reminder-sent"
  }
}

Because Shopify replaces the whole tag string on update, you pass the existing tags plus the new one. Next hour, the Filter sees payment-reminder-sent and skips the order. Save the workflow and switch it on.

Common mistakes

• Expecting it to catch Shopify Payments card declines. A declined card usually means no order exists, so there is nothing to find. For that case, an abandoned checkout sequence is the right tool. Browse the Shopify automation guides for that flavor.
• Forgetting the time floor. Without the 2 hour minimum, you email people who are literally still on the bank transfer screen. Give them room to finish on their own first.
• Skipping the tag step. If you do not write a tag back, the hourly schedule will email the same customer every single hour until they pay or you intervene. The tag is the memory that prevents this.
• Overwriting tags by accident. Always include {{ $json.tags }} in the PUT body so you append rather than wipe any tags the order already had.
• Setting the limit too low. Use limit=250 so a busy store does not leave pending orders unprocessed at the bottom of the list.

Cost at realistic volume

Say your store takes 60 pending orders a month and roughly a third of them stall long enough to need a nudge, so about 20 reminder emails go out monthly. Here is what that actually costs to run.

Even on n8n Cloud, those 720 executions a month sit comfortably inside the entry plan. If recovering even three or four stalled orders a month covers the entire stack, and it usually does several times over, the workflow pays for itself immediately.

Ready-to-import template

FAQ

Related guides

• The n8n Shopify automation hub, every order and customer workflow in one place.
• All Shopify automation guides, including abandoned checkout and win-back email flows.
• Done-for-you setup, if you would rather have the workflow installed and tuned for your store.

A Shopify abandoned cart recovery tracker in Google Sheets, built with n8n, logs every abandoned checkout to a spreadsheet and flips each row to Recovered the moment the shopper comes back and buys. You always know which carts are still open, which were saved, and how much revenue you clawed back. It runs on two Shopify triggers and one shared sheet, needs no paid recovery app, and costs effectively nothing to run.

Prefer to skip the setup? The ready-made template imports in under 10 minutes. Jump to the template section below.

What it does

Most stores treat abandoned carts as a black box: Shopify sends one or two recovery emails, and whatever happens after that is invisible. This workflow turns that black box into a living ledger.

Every time a shopper starts a checkout and walks away, n8n catches the event and writes a row to a Google Sheet: who they were, what was in the cart, how much it was worth, the recovery link, and a status of Abandoned. When that same shopper later returns and completes an order, a second flow finds the matching row by checkout ID and flips it to Recovered, stamping the date and the amount saved.

The result is a spreadsheet you actually own. Filter it to see every open cart from this week, sort by value to chase the biggest ones first, or sum the Recovered column to see exactly how much abandoned revenue you brought back. It slots neatly alongside the rest of your n8n Shopify automation stack.

Why it beats the default

Shopify already shows an abandoned checkout report, so why build this? Because the native report is a dead end. You cannot edit it, you cannot add a note, you cannot join it to anything, and you certainly cannot hand a filtered slice of it to an assistant to work through.

• It is yours. The data lives in a sheet you control. Add columns, pivot it, build a chart, or pipe it into another tool later.
• It tracks outcomes, not just events. The native report lists abandoned checkouts. This one tells you which ones were recovered and how much money came back, in the same row.
• No per-message billing. There is no recovery app subscription and no email-credit meter. The whole thing runs on webhooks and a free Google Sheet.
• It is a foundation. Once the ledger exists, layering on a Gmail nudge, a Slack alert for high-value carts, or a weekly digest is a small addition rather than a new project.

What you need

• A Shopify store on any paid plan, with an app that has read access to orders and checkouts.
• An n8n instance, either n8n Cloud or self-hosted.
• A Google account and one Google Sheet for the tracker.
• About 30 minutes to build from scratch, or under 10 with the template.

How it works — the big picture

ABANDONED CART RECOVERY TRACKER

Flow A — log abandoned carts
  [Shopify Trigger: checkouts/update] -> [Filter: has email, not paid]
        -> [Edit Fields: build row, Status = Abandoned]
        -> [Google Sheets: Append or Update on Checkout ID]
                                |
                                v
                     +----------------------+
                     |  Google Sheet ledger |
                     |  (one row per cart)  |
                     +----------------------+
                                ^
                                |
Flow B — mark recovered
  [Shopify Trigger: orders/create] -> [Edit Fields: map checkout_id, Status = Recovered]
        -> [Google Sheets: Append or Update on Checkout ID]

Node-by-node list

Seven nodes across two independent flows that share one sheet:

Step-by-step build

Build the sheet first, then the two flows.

1. Create the Google Sheet. Make a new sheet named Tracker with these headers in row 1: Checkout ID, Date, Customer, Email, Items, Cart Value, Currency, Recovery URL, Status, Recovered At. The exact spelling matters because n8n matches on these names.
2. Add the abandoned checkout trigger. Add a Shopify Trigger node, connect your Shopify credential, and set Topic to Checkout Updated (checkouts/update). Shopify fires this when a cart is started and then sits idle.
3. Filter to real abandoned carts. Add a Filter node after the trigger. Add two conditions, combined with AND: {{ $json.email }} is not empty, and {{ $json.completed_at }} is empty. This drops anonymous carts and any checkout that already became an order.
4. Shape the row. Add an Edit Fields node (Set). Switch to Manual mapping and add one assignment per column. For example, map Checkout ID to ={{ $json.id }}, Email to ={{ $json.email }}, Cart Value to ={{ $json.total_price }}, Recovery URL to ={{ $json.abandoned_checkout_url }}, and set Status to the fixed string Abandoned.
5. Log to the sheet. Add a Google Sheets node, Operation Append or Update Row. Pick your document and the Tracker sheet, then set Column to match on to Checkout ID. Map each column to the field you built in the Edit Fields node. Append or Update is what keeps one row per cart even when Shopify fires the event several times.
6. Add the recovery trigger. Add a second Shopify Trigger node with Topic Order Created (orders/create). This is a separate entry point, not wired into Flow A.
7. Mark the cart recovered. Add an Edit Fields node after it. Map Checkout ID to ={{ $json.checkout_id }}, set Status to Recovered, map Recovered At to ={{ $now.toISO() }}, and map Cart Value to ={{ $json.total_price }} so the saved amount reflects the real order.
8. Update the same row. Add a final Google Sheets node, Operation Append or Update Row, matched on Checkout ID again. Because the abandoned row already carries that checkout ID, this lands on it and flips the status instead of adding a new line.
9. Save and activate. Save the workflow and toggle it Active. Run a test checkout, then complete it, and watch the row go from Abandoned to Recovered.

The data structure

A row moves through two states. Here is the same cart before and after recovery.

Common mistakes

• Skipping the completed_at filter. Without it, every checkout update, including completed ones, lands in the tracker and inflates your abandoned count.
• Using Append instead of Append or Update. Plain Append adds a fresh row on every Shopify fire, so one cart becomes five rows. Always match on Checkout ID.
• Matching the recovery flow on email. Email is not unique per cart. Match on checkout_id so a repeat shopper does not overwrite an unrelated open cart.
• Wrong Set node version. Use the current Edit Fields node with named assignments. Old tutorials show a key-value table that behaves differently and breaks expressions.
• Confusing the topics. Use checkouts/update for abandonment and orders/create for recovery. checkouts/create fires too early, before the cart is meaningfully abandoned.

Cost at realistic volume

This is one of the cheapest automations you can run because it never touches a paid messaging service.

Self-hosted n8n makes the marginal cost zero. On n8n Cloud, even a busy store stays inside an entry plan, since each cart costs only one or two executions across both flows.

Frequently asked questions

Related guides

• Shopify abandoned checkout email sequence with n8n
• Shopify customer win-back email with n8n
• Send new Shopify orders to Google Sheets
• Browse more in the Shopify automation category.