DEV Community: Arturas Tikkivo

How to add a countdown timer to a Shopify product page (without wrecking the theme)

Arturas Tikkivo — Thu, 05 Nov 2026 07:52:52 +0000

A countdown on a product page is useful in a few narrow cases: a sale that actually ends, a pre-order window that closes Friday, a drop that goes live at a set time. It is not useful as permanent decoration. If the timer resets every day to "ends tonight", customers learn to ignore it.

I'm Arturas. I shipped Tikkivo Countdown Timer on the Shopify App Store. I'll link it once at the end. First, the setup that works with almost any theme.

When a countdown helps

Use one when there is a real deadline you control:

early-bird pricing for a workshop or tasting ends Sunday at midnight
Christmas pre-order cut-off is Dec 20 at 10:00
a limited colorway unlocks Friday at 09:00 in your store's timezone

Skip it for evergreen products. A fake urgency badge trains people to wait.

Option A: theme app embed (preferred)

Most modern countdown apps install as a theme app embed or an app block:

Install the app from the Shopify App Store.
Online Store → Themes → Customize.
Open a product template.
Add the app block (or enable the app embed in Theme settings → App embeds).
Set the end date and time in the store's timezone, not your laptop's timezone if you travel.
Save, then open the product on your phone in an Incognito window.

Check three things on mobile: the timer doesn't cover the Add to cart button, it doesn't push the price off-screen, and it still looks fine on a long product title.

Option B: a small Liquid snippet (only if you maintain the theme)

If you don't want an app, a Liquid snippet with a bit of JavaScript can render a timer from a product metafield (for example custom.sale_ends_at). This is fine when you have a developer who will own it through theme updates. It is a bad idea if you're on a locked theme and nobody on the team reads Liquid.

I won't paste a full snippet here because copy-paste timers from random blogs break on Shopify's Online Store 2.0 sections and on Checkout Extensibility. Prefer an app block when you're not comfortable maintaining code.

Settings that matter more than the design

Timezone. Store timezone in Settings → Store details. The timer should use that, not UTC guessed from the browser.
What happens at zero. Hide the block, show "Sale ended", or (if you also change the price) make sure the price change is real in Shopify, not only in the banner.
Which products show it. Attach the timer to a specific product template or metafield, not every product in the store.
Accessibility. Don't rely on color alone. Include the end date in plain text next to the digits for screen readers and for people who distrust ticking clocks.

Common mistakes

Putting the timer in the header sitewide. It becomes noise.
Running five different sale timers on one page.
Letting the timer hit zero while the discount code still works for another week.
Animations that shift the Add to cart button as the digits change (layout shift kills mobile conversion more than a missing timer ever helped).

A simple QA checklist before you publish

Desktop Chrome, phone Safari, phone Chrome
A product with a short title and one with a long title
A product with no timer (confirm it stays clean)
Cart and checkout still load (a broken app embed can take those with it)
The end moment: wait for zero, or temporarily set an end two minutes ahead and watch what happens

App I built for this

Tikkivo Countdown Timer is a Shopify app for product-page and section countdowns with an end date you control. Listing: https://apps.shopify.com/tikkivo-countdown-timer

Disclosure: I'm the developer. If a free theme block or an app you already pay for already does the job cleanly, use that. One honest deadline beats three blinking timers.

Shopify dropshipping product import - supplier feed app or dropshipping marketplace?

Arturas Tikkivo — Sun, 01 Nov 2026 19:17:30 +0000

I build Tikkivo Catalog Sync, which is a supplier-feed app, so I'm on one side of this comparison. I'll try to be clear about when the other side is the better fit.

"What's the best app to import dropshipping products into Shopify?" gets two very different kinds of answer, and people often talk past each other. The right one depends on a single question: do you already have a supplier?

If you don't have a supplier yet: a dropshipping marketplace

Apps like Syncee, Spocket, DSers (for AliExpress) and AutoDS come with a catalog of suppliers. You browse products, click import, and the app keeps stock and price in sync. Many also forward orders to the supplier.

Good when:

you're testing product ideas and don't have supplier relationships,
you want order forwarding handled for you,
you're fine with products that other stores also sell.

The trade-off is that you're tied to that marketplace's suppliers and pricing, and paid plans often limit how many products you can import.

If you already have a supplier: a supplier-feed app

Once you have a wholesaler or distributor who sends a price list, a stock file, a Google Sheet or an API, you don't need a marketplace. You need a tool that reads their data, maps it to your products and updates on a schedule. Apps in this group include syncX: Stock Sync, Stockeo, PowerFeed, Products Sync Master, Simple Inventory Sync, Feedguard and my Tikkivo Catalog Sync.

Good when:

you negotiated your own terms with the supplier,
you sell niche or branded stock that isn't on marketplaces,
you want to control titles, descriptions and pricing yourself.

What these apps usually don't do: find suppliers for you, or forward orders. Order forwarding is a separate step (email, the supplier's portal, or a dedicated app).

Questions that decide which feed app

What format does the supplier send? CSV, Excel, XML, JSON, Google Sheets, FTP, an API? This rules out apps quickly. For example, Catalog Sync doesn't read XML or FTP yet, so if that's all your supplier offers, look at Stockeo, syncX, PowerFeed or Simple Inventory Sync.
Do you need to create new products, or only update stock and price on existing ones? Some apps only update.
How often does the supplier update? Daily is fine for most. Hourly costs more and only helps if the supplier refreshes that often.
How many variants? Plans are priced by variant or SKU count.
Do you want to review changes first? If so, look for a preview step.

Where Catalog Sync fits

It's for the second group: you have a supplier who sends CSV, Excel, JSON, a published Google Sheet or a JSON REST API, and you want new products to come in as drafts and to see manual changes before they're applied. Free plan: 2,000 managed variants and 1 feed. Starter is $9/month for 5,000 variants, 3 feeds and daily updates. It launched in October 2026 and has no reviews yet, so test it on a development store first, as you should with any sync app.

Listing: https://apps.shopify.com/catalog-sync-1

If you're unsure which group you're in, describe your supplier setup in the comments and I'll say which kind of tool I'd start with.

Note: I used AI tools to help draft this post and checked every app fact against its public listing or website on 30 October 2026. Plans change, so check the listing before you install anything.

Christmas pre-orders on Shopify for a small bakery: a setup checklist

Arturas Tikkivo — Sun, 01 Nov 2026 19:17:02 +0000

Christmas is the busiest pre-order window for most bakeries, and most of the problems are decided in early November, not on December 23. This is the checklist I'd go through for a small Shopify bakery. Most of it uses Shopify's own settings.

1. Pick your last order day and write it everywhere

Choose the last day you'll accept Christmas orders and the last pickup day. Put both in the product descriptions, the collection description and the confirmation email. Customers read product pages. They rarely open an FAQ.

2. Make one Christmas collection

Put every Christmas item in one collection with its own page and a plain URL like /collections/christmas. Link it from your homepage banner. If an item is only available on some days, say that in the first line of its description.

3. Turn on local pickup

Settings → Shipping and delivery → Local pickup. Add your pickup instructions there. They appear in the order confirmation, which saves you a lot of emails.

4. Collect a pickup date

Shopify doesn't have a pickup date field out of the box. The common options:

a date picker app at cart (many have free plans; check what they charge before December)
separate variants per pickup day ("Dec 23", "Dec 24"), which is crude but works with no app
a required line item property

Whatever you choose, block the days you're closed and set a same-day cut-off.

5. Limit how many you can make

If you can bake 40 stollen a day, don't sell 60. With the variant-per-day approach you can set inventory per variant. With a date picker, check whether it supports daily order limits.

6. Test one order end to end

Place a test order, pick a date, check the confirmation email, then check where the date shows up in the Shopify admin. Note exactly where it's stored. You'll need that for step 7.

7. Plan production from the orders

Each evening you need totals per item for the next day. Export and pivot, or use an app. I built one for this, Tikkivo BakeList: it reads the date from the order (field, metafield, tag or a fallback rule) and gives you a printable bake sheet per day, with orders missing a date flagged. Free plan for 30 orders a month. Disclosure: I'm the developer. https://apps.shopify.com/tikkivo-bakelist

8. Decide what happens to late changes

Write down your rule for changes and cancellations ("up to 48 hours before pickup") and put it in the confirmation email. You'll get those messages anyway. Having the rule written down makes them quick to answer.

If you want a second pair of eyes on your Christmas setup, I do these as a small fixed-price job. Email hi@tikkivo.com.

How I turn Shopify pre-orders into a daily bake sheet

Arturas Tikkivo — Sun, 01 Nov 2026 16:30:06 +0000

If you run a small bakery on Shopify and take orders for a pickup day, you probably know this evening routine. Export the orders, open a spreadsheet, filter by date, then add up how many loaves, boxes of cookies and cakes in each size you need. Then someone edits an order at 9pm and the sheet is wrong.

Shopify is built around orders. A kitchen works in quantities per day. The gap between those two is the whole problem.

Where the date lives

The first thing to check is where your store saves the pickup or delivery date. It's usually one of these:

a cart attribute or order note written by a date picker app
an order metafield
an order tag like pickup-2026-12-23
nothing at all, because the customer picked the product called "Saturday pickup"

Open three recent orders and look. If they don't all store the date the same way, that's your first fix, before any tool. Mixed formats ("23/12", "Dec 23", "2026-12-23") are fine as long as you know which ones you have.

What the sheet needs

For each production day you want:

Every product and variant, with a total. "Sourdough, large: 34" is useful. "14 orders" is not.
Any customisation that changes the work: "no nuts", a cake message, a size.
A short list of orders that have no date or an unreadable one. This is the important part. An order with no date doesn't show up on anyone's list, so nobody bakes it, and you find out at pickup.
A split by location or pickup/delivery if you have more than one.

Doing it by hand

You can do this with an export and a pivot table: rows are product + variant, columns are dates, values are the sum of quantity. Add a filter for cancelled and refunded orders. Check the "no date" rows by eye every evening. It works. It takes 15 to 30 minutes a day in December, and it breaks every time someone edits an order after the export.

Doing it in an app

I got tired of rebuilding that pivot table, so I built a Shopify app for it, Tikkivo BakeList. You tell it where the date is (field, metafield, tag or a fallback rule), and it shows the bake sheet for any day, totalled by product and variant. Orders without a usable date go into a "needs a production date" box. You can print it or export CSV. Edits and cancellations update the sheet.

There's a free plan for 30 orders a month, which is enough to try it on a real weekend. Paid plans start at $19 a month.

Disclosure: I'm the developer. App Store page: https://apps.shopify.com/tikkivo-bakelist

If your setup stores dates somewhere I haven't listed, tell me in the comments. I'd like to support it.

Best Shopify supplier inventory sync apps compared (2026)

Arturas Tikkivo — Thu, 29 Oct 2026 20:10:33 +0000

Disclosure: I'm Arturas, the developer of Tikkivo Catalog Sync, one of the apps below. I've tried to keep this fair. Every price and feature comes from each app's public Shopify App Store listing, checked 29 October 2026, updated 30 October 2026 with four more apps. Plans change, so check the listing before you install anything.

Supplier price lists rarely match your Shopify store. Columns have different names, stock arrives as a CSV one day and a Google Sheet the next, and one bad file can wipe your inventory to zero overnight. Plenty of apps solve this, but they're built for different jobs. This guide sorts them by the job they do.

The short answer

Many suppliers, hourly or faster updates, FTP or XML feeds: syncX: Stock Sync, Stockeo or Feedguard.
Stock and price only, with strong bad-file protection (row-count checks, held items, undo): Newcraft Feed Sync, Everstock or Feedguard.
Messy supplier files, including PDF catalogs: Csvio.
Only stock and price updates on products you already have: Simple Inventory Sync, Feedguard or Stockistly.
Complex field mapping with formulas, metafields and translations: Products Sync Master.
Whole-store bulk editing, migrations and backups: Matrixify.
You don't have suppliers yet and want a dropshipping marketplace: Syncee.
Importing new supplier products as drafts from CSV, Excel, JSON, a published Google Sheet or a JSON REST API, and reviewing changes before they're applied, on a small budget: Tikkivo Catalog Sync (my app). It's new, so read the limits below.

Comparison table

App	Free plan	Entry paid plan	Formats / sources	Fastest schedule (per listing)	Rating (29 Oct 2026)
syncX: Stock Sync	2,000 products, 1 feed, manual	$7/mo: up to 2,500 products, daily	CSV, XLSX, XML, JSON; Sheets, FTP/SFTP, Dropbox, REST API	Hourly on Expert ($10/mo + add-ons)	4.8 (932)
Simple Inventory Sync	No (14-day trial)	$9/mo: 1 feed, 1,000 SKUs, daily	CSV, Excel; URL, FTP, SFTP	Every 15 min ($29/mo)	4.9 (55)
Stockeo	2,500 variants, manual	$9.99/mo: 10,000 variants, hourly	CSV, JSON, XML	Hourly	5.0 (46)
Products Sync Master	20 variants	$9.99/mo: 2,000 variants, 2 scheduled tasks	CSV, Excel, XML, Google Sheets; URL, FTP, SFTP	Scheduled tasks	4.9 (42)
Feedguard	1 feed, 1,000 variants, manual	$9/mo: 3 feeds, 5,000 variants, daily	CSV, Excel, XML, JSON; link, Sheet, FTP, SFTP	Every 15 min ($29/mo)	New, no reviews yet
Stockistly	No (30-day trial)	$20/mo: 3 feeds, 5,000 variants, daily	CSV, XML, API, FTP, Sheets, email	4×/day ($70/mo)	4.7 (18)
Matrixify	Demo: 10 items per file	$20/mo	Excel, CSV, Google Sheets, FTP/SFTP, Drive, Dropbox	Scheduled / repeating jobs	4.9 (1,837)
Syncee	25 products	$39.99/mo: 100 products	Supplier marketplace	Automatic	4.2 (554)
PowerFeed	3,000 variants per source, 1 source, manual	$9/mo: 5,000 variants, 1 source, 2 runs/day	CSV, Excel, XML, JSON, Sheets, FTP/SFTP, APIs	16 runs/day ($99/mo)	5.0 (6)
Newcraft Feed Sync	No (7-day trial)	$9/mo: 1 feed, every 6 h, stock and price	CSV, Excel, XML, JSON; link, SFTP, Sheets, upload	Every 15 min ($79/mo)	New, no reviews yet
Everstock	1 connection, manual, up to 2,000 items per run	$9/mo: 1 connection, every 6 h	REST/JSON/XML API, WooCommerce, CSV/XLSX, FTP/SFTP, Sheets	Hourly ($79/mo)	See listing
Csvio	30 products, 3 imports/month	$19/mo Starter	CSV, Excel, PDF; scheduled URL/FTP/SFTP	Scheduled	See listing
Tikkivo Catalog Sync	2,000 variants, 1 feed, unlimited manual updates	$9/mo: 5,000 variants, 3 feeds, daily	CSV, XLSX, JSON; HTTPS feeds, published Sheets CSV, JSON REST API	Daily (Starter)	New, no reviews yet

The apps, one by one

syncX: Stock Sync: the established all-rounder

It has the most reviews in this category and the most ways to connect: Google Sheets, FTP/SFTP, Dropbox, online files and REST APIs, plus multi-store sync. Entry pricing is low ($7/mo), but per-feed and per-product add-ons can raise the real cost, so price out your own SKU count. Best for: stores with many suppliers or several Shopify stores.

Simple Inventory Sync: focused on updating stock

It updates quantities, prices, cost, barcodes and weight on variants you already have, from CSV, Excel, URL, FTP or SFTP. It also has low-stock alerts and valuation exports, and syncs as often as every 15 minutes on the $29 plan. Best for: stores that already have their products and just need stock and prices kept current.

Stockeo: simple hourly feed sync

It handles CSV, JSON and XML feeds, imports products and syncs inventory, and runs hourly on every paid plan. The free plan covers 2,500 variants with manual runs. Best for: a cheap, simple hourly schedule.

Products Sync Master: the most mapping control

Formulas, filters, saved templates, metafields and translation import, with CSV, Excel, XML and Google Sheets over URL/FTP/SFTP. The free plan is only 20 variants, so it's really a trial. Best for: messy supplier files that need transformation rules.

Feedguard: safety-first stock sync

It's new (launched 20 Oct 2026). It focuses on protection: the first sync stops at a preview, syncs halt if a file looks wrong, and any sync can be undone in one click. It supports XML and FTP/SFTP. Best for: stock and price updates on existing variants when a bad supplier file is your biggest worry.

Stockistly: stock and price sync with alerts

Broad inputs (including email feeds) and markup rules, with a 30-day trial. There's no free plan and it starts at $20/mo. Best for: wholesale and multi-warehouse stores that want hands-on setup help.

Matrixify: the bulk data Swiss-army knife

It isn't really a supplier-sync app. It's a bulk import/export and migration tool for almost every Shopify data type, with scheduled jobs. It expects files in its own template. Best for: migrations, backups and large-scale bulk edits.

Syncee: a supplier marketplace, not a feed tool

Syncee helps you find dropshipping suppliers, then syncs and forwards orders. Best for: stores without suppliers yet.

Newer apps worth a look (October 2026)

Newcraft Feed Sync, Everstock and Feedguard all launched or grew in October 2026 and focus on safe stock and price updates: a preview of old and new values, stopping files that are much shorter than usual, and (Everstock, Feedguard) undo. PowerFeed, from a New Zealand team, covers almost every source type including XML and FTP. Csvio is aimed at importing messy supplier files as they arrive, and reads PDF catalogs. Sources: each app's App Store listing, and sync.usenormalize.com for Everstock, checked 30 Oct 2026.

Tikkivo Catalog Sync (mine)

What it does: Connect a CSV, XLSX or JSON file, an HTTPS feed, a published Google Sheet (CSV) or a read-only JSON REST API. Map only the fields each supplier should control. Import new products as drafts or update your existing catalog. Manual updates show a preview of the proposed changes before you approve them. It also has price rules, available stock at one selected location, grouped variants, images, categories, metafields, bulk editing and downloadable result reports. The free plan covers 2,000 managed variants and 1 feed. Starter is $9/mo for 5,000 variants, 3 feeds and daily scheduled updates. Growth is $19/mo for 10,000 variants and 10 feeds.

When NOT to choose it (honestly):

Your supplier only offers XML or FTP/SFTP. Those aren't supported in this release, so use Stockeo, syncX, Feedguard or Simple Inventory Sync.
You need hourly or near-real-time stock. Starter schedules daily.
You have more than 10,000 variants or sync several Shopify stores.
You want an app with a long review history. Catalog Sync launched on 13 Oct 2026 and has no reviews yet.
You need dropshipping order forwarding. It doesn't do that.

Best for: small and mid-size stores that add new supplier products often, get files in CSV, Excel, JSON or Google Sheets, and want to review changes before they reach live products.

Five questions to ask before you pick any of them

What format does your supplier actually send? CSV, XML, JSON, API, FTP or email? That rules out half the list on its own.
Do you need new products created, or only existing ones updated? Stock-only tools are simpler and cheaper.
How often does stock really change? Daily is enough for most suppliers, and hourly costs more.
What happens with a bad file? Look for a preview, change limits or undo before trusting a schedule.
Which fields does the supplier own? Map only price and stock if you rewrite titles and descriptions yourself.

Whatever you choose, test it on a development store or with a few SKUs first.

Note: I used AI tools to help draft this post. Prices and features are from each app's public Shopify App Store page, checked 29 October 2026.

A free n8n template to auto-tag Shopify orders (high-value, first order, risky) and alert Slack

Arturas Tikkivo — Thu, 29 Oct 2026 17:35:09 +0000

Order tags are the cheapest automation a Shopify store has. Once an order says high-value or risk-high, you can filter the order list by it, build a saved view for the packing team, trigger Shopify Flow, or exclude it from an auto-fulfilment app. The hard part is getting the tags on in the first place, consistently, without someone clicking through every order.

This is the third free n8n workflow I'm sharing, after the low-stock alerts and the supplier stock and price sync. It has 15 working nodes plus setup notes, dry-run mode on by default, and the full JSON is at the end.

What it does

Every 15 minutes:

Config holds the shop URL, the rules and the tag names. Leave a tag empty and that rule is off.
Get Shopify token swaps your app's client ID and secret for a short-lived Admin API token, so the secret stays in an n8n credential.
Build order query creates the search for the last 24 hours, and only requests the fields your enabled rules need.
Fetch recent orders pages through the results, retrying throttled pages.
Decide tags applies the rules below. It writes nothing.
In dry-run mode the plan goes straight to Slack. In live mode, Add tags in Shopify sends up to 25 orders per request and Check results counts what Shopify actually accepted.
Slack gets a short report, with links to the orders that need a human.
An error branch posts to Slack when a production run fails.

The rules:

Tag	When
`high-value`	order total ≥ `highValueAmount`, in shop currency
`first-order`	the customer's order count is 1
`repeat-customer`	order count ≥ `repeatCustomerMinOrders` (default 3)
`risk-high` / `risk-medium`	Shopify's risk assessment is HIGH/MEDIUM, or the recommendation is CANCEL/INVESTIGATE
`international`	ships outside `homeCountry` (off by default)
`express`	the shipping line contains "express", "next day" or "priority"
`guest`	no customer on the order (off by default)

It only adds tags. It never removes one, never edits or cancels an order, and never sends customer names or emails to Slack. The report holds the order number, the total and the tags.

Setup (about 10 minutes)

In Shopify's Dev Dashboard, create an app with read_orders, write_orders and read_customers. Under protected customer data, request access to customer data. The order count lives on the customer, and without it the request fails (more on that below). If you turn on the international rule, the shipping address is also protected data, so include addresses.
Install the app on your store and copy the client ID and secret.
In n8n, create a Custom Auth credential with {"body": {"client_id": "…", "client_secret": "…"}} and select it in Get Shopify token.
Fill in Config. Paste your Slack incoming-webhook URL there and in Slack error alert, because the error branch runs as its own execution and can't read Config.
Under Workflow settings → Error workflow, pick this same workflow.
Run it once with dryRun = true. Then set it to false and activate it.

Using test orders on a development store? Set includeTestOrders = true, or every Bogus Gateway order gets skipped as a test.

What the report looks like

This is the dry-run report from one of my runs:

*Shopify order tagger* — DRY RUN, nothing was written
Orders checked: 9 (last 24h) · would tag: 5 · alerts: 4
Skipped: test orders 1, cancelled 1, too new 1, waiting for risk analysis 1
*Needs a look:*
• #1001 320.00 EUR → high-value, first-order
• #1003 89.90 EUR → first-order, risk-high (risk HIGH)
• #1008 260.00 EUR → high-value, express
• #1011 75.50 EUR → risk-medium (risk MEDIUM)
*Tags only:*
• #1002 45.00 EUR → repeat-customer

In Slack each order number is a link to the order in your admin. Which new tags count as alerts is up to you (alertTags). Orders that only get quiet tags like repeat-customer are tagged without a message, so the channel stays readable. If you'd also like a message when there's nothing to do, turn on notifyEveryRun.

The gotchas

I built and ran it against a test Shopify API on n8n 2.44.5. These are the things that shaped the design.

1. Use tagsAdd, not orderUpdate

The obvious mutation is orderUpdate(input: {id, tags}). But tags there is the full list: it replaces what's on the order. If a staff member added gift-wrap a minute earlier, it's gone. tagsAdd only adds, and adding a tag that's already there does nothing. So a retry is harmless too.

mutation Tag($id0: ID!, $t0: [String!]!, $id1: ID!, $t1: [String!]!) {
  b0_o0: tagsAdd(id: $id0, tags: $t0) { node { id } userErrors { field message } }
  b0_o1: tagsAdd(id: $id1, tags: $t1) { node { id } userErrors { field message } }
}

Each order gets its own alias, so one request covers 25 orders. The alias also tells Check results which order a result belongs to. In one test I made Shopify reject the tags on a single order. The other four were tagged, the report listed the error, and the next run picked up that order.

2. Fresh orders aren't finished yet

Right after checkout, Shopify's fraud analysis can still be running. The assessment comes back as PENDING, or there isn't one yet. If you evaluate the order at that moment, every order looks safe.

So the workflow leaves orders younger than minOrderAgeMinutes (10) alone. If risk is still pending, it waits up to maxRiskWaitMinutes (60) before tagging anyway, and notes "risk analysis not finished" in the report. In my tests, an order with a pending assessment was skipped. After I switched its assessment to LOW, the next run tagged it.

3. Don't keep state. Use a marker tag.

How do you avoid tagging and alerting the same order every 15 minutes? You could store processed IDs in a database or n8n's static data. I went simpler. Every handled order also gets auto-tagged, in the same call as its other tags. The search excludes orders that already have it, and the Code node checks again in case the search ever doesn't.

That gives you three useful properties:

If a write fails, the marker isn't there, so the order is retried next run.
The lookback window (24h) can be much longer than the schedule (15 min). A missed run or a short n8n outage loses nothing.
In the Shopify admin you can see which orders the workflow has handled.

The search uses a full UTC timestamp (created_at:>='2026-10-28T17:15:34Z'), not a date like 2026-10-28. Shopify can read date-only values in the store's timezone, and the window then quietly shifts by a few hours.

4. Partial data with errors is worse than a failure

If the app doesn't have protected customer data access, Shopify can still answer with HTTP 200. Your orders come back, but customer is null, and an ACCESS_DENIED error sits next to the data. If you only look at data, every customer becomes a guest. No first-order tag ever appears, and nothing tells you why.

Decide tags treats any GraphQL error as fatal. It stops before writing and puts a hint in the error message:

Shopify returned an error, nothing was tagged: [{"message":"This app is not approved to access
the Customer object…","extensions":{"code":"ACCESS_DENIED"}}] -> Check the app scopes
(read_orders, write_orders, read_customers) and request protected customer data access…

The same goes for a half-loaded order list. If the last page still says hasNextPage: true, the run stops.

5. Small type traps

customer.numberOfOrders is an UnsignedInt64, which arrives as a string ("1"). Convert it before comparing. It includes the current order, so a first order is 1, not 0.
Use totalPriceSet.shopMoney, not presentmentMoney. A customer paying 346.10 USD on a EUR store should be compared against your EUR threshold.
Shopify treats a comma in a tag as a separator, so high value, VIP becomes two tags. The workflow refuses tag names that contain a comma or are longer than 40 characters.

6. Throttling arrives as HTTP 200

As with the supplier sync, a throttled GraphQL call can return HTTP 200 with THROTTLED in errors, so n8n's Retry on fail never triggers. Both HTTP nodes use the pagination settings as a retry loop. A throttled read keeps the same cursor, and a throttled write is sent again, up to 6 times, 2 seconds apart. In my test, two throttled reads and two throttled writes still ended with every order tagged once.

One thing to check before you go live

Adding a tag fires the orders/updated webhook. If you have Shopify Flow rules or apps that react to order updates or tags, they'll run on these orders too. That's often the point, since "if tagged risk-high, hold fulfilment" is a great Flow, but look at what's listening first.

Ideas to extend it

Add a Telegram or email node next to the Slack one.
A wholesale tag when the customer has a B2B tag.
A po-box tag by checking address1 (needs address access).
Put the order count rules on customer tags as well, using tagsAdd on the customer ID (needs write_customers).

The template

In n8n, open a new workflow and paste this with Ctrl/Cmd+V, or save it as a .json file and use Import from file.

{
 "name": "Shopify order auto-tagger + Slack alerts (free, by Tikkivo)",
 "nodes": [
  {"parameters": {"content": "## Shopify order auto-tagger + alerts\n**Free template by Arturas (Tikkivo)**\n\nEvery 15 minutes it looks at recent orders and **adds** tags: `high-value`, `first-order`, `repeat-customer`, `risk-high`, `risk-medium`, `international`, `express`. Orders that need a human (high value, risky) are posted to Slack with a link. It never removes tags, never edits or cancels orders, and never sends customer names or emails to Slack.\n\n### Setup (10 min)\n1. Shopify **Dev Dashboard** → create an app with scopes `read_orders, write_orders, read_customers`. Under **protected customer data**, request access to customer data (needed for the order count). Install it, copy client ID + secret.\n2. n8n → Credentials → **Custom Auth**:\n`{\"body\": {\"client_id\": \"…\", \"client_secret\": \"…\"}}`\nSelect it in **Get Shopify token**.\n3. Fill in **Config**. Paste the Slack webhook in Config **and** in **Slack error alert**.\n4. Workflow settings → **Error workflow** → choose *this workflow*.\n5. Run with `dryRun = true`, read the Slack report, then set `dryRun = false` and activate.", "width": 420, "height": 820, "color": 4}, "name": "Sticky: setup", "type": "n8n-nodes-base.stickyNote", "typeVersion": 1, "position": [-460, -460], "id": "0f7a1c00-0000-4000-8000-000000000000"},
  {"parameters": {"content": "### Config cheat sheet\n- **dryRun** (default ON): reports what it *would* tag, writes nothing\n- **lookbackHours**: how far back to look each run (keep it much longer than the schedule; the marker tag prevents double work)\n- **minOrderAgeMinutes**: leave brand-new orders alone so fraud analysis and other apps can finish\n- **maxRiskWaitMinutes**: if risk is still pending after this, tag the order anyway\n- **highValueAmount**: in your **shop currency** (not the customer's)\n- **repeatCustomerMinOrders**: lifetime orders, this one included\n- **homeCountry**: e.g. `LT`. Empty = international rule off (and no address is requested)\n- **any tag empty** = that rule is off\n- **processedTag**: added to every order the workflow has handled, so it's skipped next time. Empty = off\n- **alertTags**: new tags that trigger a Slack alert in live mode", "width": 440, "height": 640, "color": 7}, "name": "Sticky: config", "type": "n8n-nodes-base.stickyNote", "typeVersion": 1, "position": [-20, -460], "id": "0f7a1c00-0000-4000-8000-000000000001"},
  {"parameters": {"content": "### Safety built in\n- Uses `tagsAdd`, which only **adds**. `orderUpdate(tags:)` would replace all tags, including your staff's\n- Throttled responses (HTTP 200 + `THROTTLED`) are retried by the pagination settings\n- Incomplete order list or any GraphQL error → stops **before** writing\n- The marker tag is written in the same call as the other tags, so a failed write is simply retried next run\n- Tagging fires `orders/updated`: check Shopify Flow or apps that react to tags", "width": 460, "height": 320, "color": 6}, "name": "Sticky: safety", "type": "n8n-nodes-base.stickyNote", "typeVersion": 1, "position": [1300, -460], "id": "0f7a1c00-0000-4000-8000-000000000002"},
  {"parameters": {"content": "### Old store app with a `shpat_` token?\nDelete **Get Shopify token**, connect **Config** → **Build order query**. In **Fetch recent orders** and **Add tags in Shopify** switch Authentication to *Generic → Header Auth* with a credential `X-Shopify-Access-Token: shpat_…` and remove the token header row.", "width": 400, "height": 260, "color": 5}, "name": "Sticky: legacy token", "type": "n8n-nodes-base.stickyNote", "typeVersion": 1, "position": [460, -460], "id": "0f7a1c00-0000-4000-8000-000000000003"},
  {"parameters": {"content": "### Error alerts\nRuns when any production execution fails (Workflow settings → Error workflow → this workflow). Paste your Slack webhook URL in the node.", "width": 440, "height": 200, "color": 3}, "name": "Sticky: errors", "type": "n8n-nodes-base.stickyNote", "typeVersion": 1, "position": [-20, 480], "id": "0f7a1c00-0000-4000-8000-000000000004"},
  {"parameters": {"rule": {"interval": [{"field": "minutes", "minutesInterval": 15}]}}, "name": "Every 15 minutes", "type": "n8n-nodes-base.scheduleTrigger", "typeVersion": 1.2, "position": [0, 200], "id": "0f7a1c00-0000-4000-8000-000000000005"},
  {"parameters": {}, "name": "Run manually", "type": "n8n-nodes-base.manualTrigger", "typeVersion": 1, "position": [0, 360], "id": "0f7a1c00-0000-4000-8000-000000000006"},
  {"parameters": {"assignments": {"assignments": [{"id": "cfg1", "name": "shopUrl", "value": "https://your-store.myshopify.com", "type": "string"}, {"id": "cfg2", "name": "apiVersion", "value": "2026-10", "type": "string"}, {"id": "cfg3", "name": "dryRun", "value": true, "type": "boolean"}, {"id": "cfg4", "name": "lookbackHours", "value": 24, "type": "number"}, {"id": "cfg5", "name": "minOrderAgeMinutes", "value": 10, "type": "number"}, {"id": "cfg6", "name": "maxRiskWaitMinutes", "value": 60, "type": "number"}, {"id": "cfg7", "name": "includeTestOrders", "value": false, "type": "boolean"}, {"id": "cfg8", "name": "skipCancelled", "value": true, "type": "boolean"}, {"id": "cfg9", "name": "highValueAmount", "value": 250, "type": "number"}, {"id": "cfg10", "name": "highValueTag", "value": "high-value", "type": "string"}, {"id": "cfg11", "name": "firstOrderTag", "value": "first-order", "type": "string"}, {"id": "cfg12", "name": "repeatCustomerTag", "value": "repeat-customer", "type": "string"}, {"id": "cfg13", "name": "repeatCustomerMinOrders", "value": 3, "type": "number"}, {"id": "cfg14", "name": "guestTag", "value": "", "type": "string"}, {"id": "cfg15", "name": "riskHighTag", "value": "risk-high", "type": "string"}, {"id": "cfg16", "name": "riskMediumTag", "value": "risk-medium", "type": "string"}, {"id": "cfg17", "name": "homeCountry", "value": "", "type": "string"}, {"id": "cfg18", "name": "internationalTag", "value": "international", "type": "string"}, {"id": "cfg19", "name": "expressKeywords", "value": "express,next day,priority", "type": "string"}, {"id": "cfg20", "name": "expressTag", "value": "express", "type": "string"}, {"id": "cfg21", "name": "processedTag", "value": "auto-tagged", "type": "string"}, {"id": "cfg22", "name": "alertTags", "value": "high-value,risk-high,risk-medium", "type": "string"}, {"id": "cfg23", "name": "slackWebhookUrl", "value": "https://hooks.slack.com/services/XXX/YYY/ZZZ", "type": "string"}, {"id": "cfg24", "name": "notifyEveryRun", "value": false, "type": "boolean"}]}, "options": {}}, "name": "Config", "type": "n8n-nodes-base.set", "typeVersion": 3.4, "position": [220, 280], "id": "0f7a1c00-0000-4000-8000-000000000007"},
  {"parameters": {"method": "POST", "url": "={{ $json.shopUrl }}/admin/oauth/access_token", "authentication": "genericCredentialType", "genericAuthType": "httpCustomAuth", "sendBody": true, "specifyBody": "json", "jsonBody": "{ \"grant_type\": \"client_credentials\" }", "options": {}}, "name": "Get Shopify token", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [440, 280], "credentials": {"httpCustomAuth": {"id": "shopifyOrderTag01", "name": "Shopify app (client id + secret)"}}, "id": "0f7a1c00-0000-4000-8000-000000000008"},
  {"parameters": {"jsCode": "// Build the order search for this run. Only the fields the enabled rules need are requested.\nconst cfg = $('Config').first().json;\nconst hours = Number(cfg.lookbackHours) > 0 ? Number(cfg.lookbackHours) : 24;\n// Always search in UTC with a full timestamp. A date-only filter like created_at:>=2026-10-28\n// is read in the *store's* timezone, which silently shifts the window.\nconst since = new Date(Date.now() - hours * 3600e3).toISOString();\nconst marker = String(cfg.processedTag || '').trim();\nlet q = `created_at:>='${since}'`;\nif (marker) q += ` tag_not:'${marker}'`;           // the Code node double-checks this anyway\nconst fields = [\n  'id', 'name', 'createdAt', 'test', 'cancelledAt', 'tags',\n  'totalPriceSet { shopMoney { amount currencyCode } }',\n  'customer { id numberOfOrders }',\n  'shippingLines(first: 5) { nodes { title } }',\n  'risk { recommendation assessments { riskLevel } }',\n];\n// Address is protected customer data. Only ask for it when the \"international\" rule is on.\nif (String(cfg.homeCountry || '').trim()) fields.push('shippingAddress { countryCodeV2 }');\nconst query = `query Orders($after: String, $q: String!) { orders(first: 50, after: $after, query: $q, sortKey: CREATED_AT) { pageInfo { hasNextPage endCursor } nodes { ${fields.join(' ')} } } }`;\nreturn [{ json: { query, q, since } }];\n"}, "name": "Build order query", "type": "n8n-nodes-base.code", "typeVersion": 2, "position": [660, 280], "id": "0f7a1c00-0000-4000-8000-000000000009"},
  {"parameters": {"method": "POST", "url": "={{ $('Config').first().json.shopUrl }}/admin/api/{{ $('Config').first().json.apiVersion }}/graphql.json", "sendHeaders": true, "headerParameters": {"parameters": [{"name": "X-Shopify-Access-Token", "value": "={{ $('Get Shopify token').first().json.access_token }}"}]}, "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify({ query: $('Build order query').first().json.query, variables: { after: null, q: $('Build order query').first().json.q } }) }}", "options": {"pagination": {"pagination": {"parameters": {"parameters": [{"type": "body", "name": "variables", "value": "={{ { after: ($response.body.data && $response.body.data.orders) ? $response.body.data.orders.pageInfo.endCursor : $request.body.variables.after, q: $('Build order query').first().json.q } }}"}]}, "paginationCompleteWhen": "other", "completeExpression": "={{ JSON.stringify($response.body.errors || '').includes('THROTTLED') ? false : !($response.body.data && $response.body.data.orders && $response.body.data.orders.pageInfo.hasNextPage) }}", "limitPagesFetched": true, "maxRequests": 200, "requestInterval": 1000}}}}, "name": "Fetch recent orders", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [880, 280], "retryOnFail": true, "maxTries": 3, "waitBetweenTries": 5000, "id": "0f7a1c00-0000-4000-8000-000000000010"},
  {"parameters": {"jsCode": "// Decide tags. Nothing is written here; writes only happen in \"Add tags in Shopify\" when dryRun is false.\nconst cfg = $('Config').first().json;\nconst bool = v => v === true || String(v).trim().toLowerCase() === 'true';\nconst num = (v, d) => (v === '' || v == null || isNaN(Number(v))) ? d : Number(v);\nconst list = s => String(s ?? '').split(',').map(x => x.trim()).filter(Boolean);\nconst lc = s => String(s).toLowerCase();\n\nconst dryRun = bool(cfg.dryRun);\nconst now = Date.now();\nconst since = Date.parse($('Build order query').first().json.since);\nconst minAge = num(cfg.minOrderAgeMinutes, 10) * 60e3;\nconst riskWait = num(cfg.maxRiskWaitMinutes, 60) * 60e3;\nconst marker = String(cfg.processedTag || '').trim();\nconst homeCountry = String(cfg.homeCountry || '').trim().toUpperCase();\nconst expressWords = list(cfg.expressKeywords).map(lc);\nconst alertTags = new Set(list(cfg.alertTags).map(lc));\nconst T = {\n  highValue: String(cfg.highValueTag || '').trim(), first: String(cfg.firstOrderTag || '').trim(),\n  repeat: String(cfg.repeatCustomerTag || '').trim(), guest: String(cfg.guestTag || '').trim(),\n  riskHigh: String(cfg.riskHighTag || '').trim(), riskMedium: String(cfg.riskMediumTag || '').trim(),\n  intl: String(cfg.internationalTag || '').trim(), express: String(cfg.expressTag || '').trim(),\n};\nfor (const t of [...Object.values(T), marker]) {\n  if (t && (t.includes(',') || t.length > 40)) throw new Error(`Config: tag \"${t}\" is invalid (no commas, max 40 characters).`);\n}\n\n// ---------- 1. Collect pages. Throttled pages were retried by the HTTP node and carry no data. ----------\nlet throttled = 0, last = null; const byId = new Map();\nfor (const { json: p } of $input.all()) {\n  const errs = JSON.stringify(p.errors || '');\n  if (errs.includes('THROTTLED')) { throttled++; continue; }\n  if (p.errors) {\n    const hint = errs.includes('ACCESS_DENIED')\n      ? ' -> Check the app scopes (read_orders, write_orders, read_customers) and request protected customer data access in the Dev Dashboard.' : '';\n    throw new Error('Shopify returned an error, nothing was tagged: ' + errs.slice(0, 300) + hint);\n  }\n  if (!p.data || !p.data.orders) throw new Error('Unexpected response from Shopify, nothing was tagged: ' + JSON.stringify(p).slice(0, 200));\n  for (const o of p.data.orders.nodes) byId.set(o.id, o);\n  last = p.data.orders;\n}\nif (!last || last.pageInfo.hasNextPage) throw new Error('Order list is incomplete (pagination stopped early). Nothing was tagged.');\n\n// ---------- 2. Apply the rules ----------\nconst skip = { 'outside window': 0, 'already done': 0, 'test orders': 0, cancelled: 0, 'too new': 0, 'waiting for risk analysis': 0 };\nconst plans = [];\nfor (const o of byId.values()) {\n  const created = Date.parse(o.createdAt);\n  const has = new Set((o.tags || []).map(lc));\n  if (created < since) { skip['outside window']++; continue; }               // don't trust the search filter blindly\n  if (marker && has.has(lc(marker))) { skip['already done']++; continue; }\n  if (o.test && !bool(cfg.includeTestOrders)) { skip['test orders']++; continue; }\n  if (o.cancelledAt && bool(cfg.skipCancelled)) { skip.cancelled++; continue; }\n  const age = now - created;\n  if (age < minAge) { skip['too new']++; continue; }\n  const levels = ((o.risk || {}).assessments || []).map(a => a.riskLevel);\n  const riskPending = levels.length === 0 || levels.includes('PENDING');\n  if (riskPending && age < riskWait) { skip['waiting for risk analysis']++; continue; } // try again next run\n\n  const add = [], why = [];\n  const money = (o.totalPriceSet || {}).shopMoney || {};                 // shop currency, not what the customer paid in\n  if (T.highValue && Number(money.amount) >= num(cfg.highValueAmount, Infinity)) add.push(T.highValue);\n  const orders = o.customer ? Number(o.customer.numberOfOrders) : null;  // UnsignedInt64 arrives as a string\n  if (orders === null) { if (T.guest) add.push(T.guest); }\n  else if (orders <= 1) { if (T.first) add.push(T.first); }\n  else if (T.repeat && orders >= num(cfg.repeatCustomerMinOrders, 3)) add.push(T.repeat);\n  const rec = (o.risk || {}).recommendation;\n  if (levels.includes('HIGH') || rec === 'CANCEL') { if (T.riskHigh) add.push(T.riskHigh); why.push('risk HIGH'); }\n  else if (levels.includes('MEDIUM') || rec === 'INVESTIGATE') { if (T.riskMedium) add.push(T.riskMedium); why.push('risk MEDIUM'); }\n  if (riskPending) why.push('risk analysis not finished');\n  const cc = (o.shippingAddress || {}).countryCodeV2;\n  if (homeCountry && T.intl && cc && cc !== homeCountry) { add.push(T.intl); why.push('ships to ' + cc); }\n  const ship = ((o.shippingLines || {}).nodes || []).map(s => lc(s.title || ''));\n  if (T.express && expressWords.some(w => ship.some(s => s.includes(w)))) add.push(T.express);\n\n  const newTags = [...new Set(add)].filter(t => !has.has(lc(t)));\n  const writeTags = marker ? [...newTags, marker] : newTags;\n  if (!writeTags.length) continue;\n  plans.push({\n    id: o.id, name: o.name, total: `${money.amount} ${money.currencyCode}`, newTags, writeTags, why,\n    alert: newTags.some(t => alertTags.has(lc(t))),\n    url: `${String(cfg.shopUrl).replace(/\\/+$/, '')}/admin/orders/${o.id.split('/').pop()}`,\n  });\n}\n\n// ---------- 3. API batches: up to 25 orders per request, one alias per order ----------\nconst size = 25, batches = [];\nfor (let i = 0; i < plans.length; i += size) {\n  const chunk = plans.slice(i, i + size), b = batches.length;\n  const vars = {}, defs = [], calls = [];\n  chunk.forEach((p, j) => {\n    vars['id' + j] = p.id; vars['t' + j] = p.writeTags;\n    defs.push(`$id${j}: ID!, $t${j}: [String!]!`);\n    calls.push(`b${b}_o${j}: tagsAdd(id: $id${j}, tags: $t${j}) { node { id } userErrors { field message } }`);\n  });\n  batches.push({ ids: chunk.map(p => p.id), body: { query: `mutation Tag(${defs.join(', ')}) { ${calls.join(' ')} }`, variables: vars } });\n}\n\n// ---------- 4. Report (order numbers and totals only, no customer names or emails) ----------\nfor (const p of plans)\n  p.line = `• <${p.url}|${p.name}> ${p.total} → ${p.newTags.join(', ') || '(checked, no rule matched)'}${p.why.length ? ' (' + p.why.join(', ') + ')' : ''}`;\nconst skipText = Object.entries(skip).filter(([, n]) => n).map(([k, n]) => `${k} ${n}`).join(', ');\nconst intro = `Orders checked: ${byId.size} (last ${num(cfg.lookbackHours, 24)}h)`;\nconst alerts = plans.filter(p => p.alert), rest = plans.filter(p => !p.alert && p.newTags.length);\nconst out = ['*Shopify order tagger* — DRY RUN, nothing was written',\n  `${intro} · would tag: ${plans.length} · alerts: ${alerts.length}`];\nif (skipText) out.push('Skipped: ' + skipText);\nif (alerts.length) out.push('*Needs a look:*', ...alerts.slice(0, 20).map(p => p.line));\nif (rest.length) out.push('*Tags only:*', ...rest.slice(0, 20).map(p => p.line));\nif (rest.length > 20) out.push(`…and ${rest.length - 20} more`);\nconst notify = dryRun ? (plans.length > 0 || bool(cfg.notifyEveryRun)) : (plans.length === 0 && bool(cfg.notifyEveryRun));\nconst text = dryRun ? out.join('\\n') : `*Shopify order tagger* — LIVE\\n${intro} · nothing to tag`;\nreturn [{ json: { dryRun, notify, text, intro, skipText, plans, batches, batchCount: batches.length, ordersChecked: byId.size, throttledReads: throttled } }];\n"}, "name": "Decide tags", "type": "n8n-nodes-base.code", "typeVersion": 2, "position": [1100, 280], "id": "0f7a1c00-0000-4000-8000-000000000011"},
  {"parameters": {"conditions": {"options": {"caseSensitive": true, "leftValue": "", "typeValidation": "strict", "version": 2}, "conditions": [{"id": "c1", "leftValue": "={{ $json.dryRun || $json.batchCount === 0 }}", "rightValue": "", "operator": {"type": "boolean", "operation": "true", "singleValue": true}}], "combinator": "and"}, "options": {}}, "name": "Dry run or nothing to tag?", "type": "n8n-nodes-base.if", "typeVersion": 2.2, "position": [1320, 280], "id": "0f7a1c00-0000-4000-8000-000000000012"},
  {"parameters": {"fieldToSplitOut": "batches", "options": {}}, "name": "Split into API batches", "type": "n8n-nodes-base.splitOut", "typeVersion": 1, "position": [1540, 400], "id": "0f7a1c00-0000-4000-8000-000000000013"},
  {"parameters": {"method": "POST", "url": "={{ $('Config').first().json.shopUrl }}/admin/api/{{ $('Config').first().json.apiVersion }}/graphql.json", "sendHeaders": true, "headerParameters": {"parameters": [{"name": "X-Shopify-Access-Token", "value": "={{ $('Get Shopify token').first().json.access_token }}"}]}, "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify($json.body) }}", "options": {"batching": {"batch": {"batchSize": 1, "batchInterval": 1000}}, "pagination": {"pagination": {"parameters": {"parameters": [{"type": "headers", "name": "X-Attempt", "value": "={{ $pageCount + 1 }}"}]}, "paginationCompleteWhen": "other", "completeExpression": "={{ !(JSON.stringify($response.body.errors || '').includes('THROTTLED')) }}", "limitPagesFetched": true, "maxRequests": 6, "requestInterval": 2000}}}}, "name": "Add tags in Shopify", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [1760, 400], "retryOnFail": true, "maxTries": 2, "waitBetweenTries": 5000, "id": "0f7a1c00-0000-4000-8000-000000000014"},
  {"parameters": {"jsCode": "// Check results. The HTTP node returns one item per response, throttled retries included, and not always\n// in batch order. The alias (b0_o3 = batch 0, order 3) says which order each result belongs to.\nconst plan = $('Decide tags').first().json;\nconst ok = new Set(); const errors = []; let throttled = 0; const seen = new Set();\nfor (const { json: r } of $input.all()) {\n  const errs = JSON.stringify(r.errors || '');\n  if (errs.includes('THROTTLED')) { throttled++; continue; }\n  if (r.errors) { errors.push(errs.slice(0, 200)); continue; }\n  for (const [alias, res] of Object.entries(r.data || {})) {\n    const m = alias.match(/^b(\\d+)_o(\\d+)$/); if (!m) continue;\n    const id = plan.batches[Number(m[1])].ids[Number(m[2])]; seen.add(id);\n    const p = plan.plans.find(x => x.id === id);\n    if (res && res.node && !(res.userErrors || []).length) ok.add(id);\n    else errors.push(`${p.name}: ${(res.userErrors || []).map(e => e.message).join('; ') || 'not tagged'} (will retry next run)`);\n  }\n}\nfor (const p of plan.plans) if (!seen.has(p.id) && !errors.some(e => e.startsWith(p.name + ':')))\n  errors.push(`${p.name}: not applied (still throttled or rejected), will retry next run`);\nconst done = plan.plans.filter(p => ok.has(p.id));\nconst alerts = done.filter(p => p.alert), rest = done.filter(p => !p.alert && p.newTags.length);\nconst out = ['*Shopify order tagger* — LIVE',\n  `${plan.intro} · tagged: ${done.length}/${plan.plans.length} · alerts: ${alerts.length} · errors: ${errors.length}`];\nif (plan.skipText) out.push('Skipped: ' + plan.skipText);\nif (alerts.length) out.push('*Needs a look:*', ...alerts.slice(0, 20).map(p => p.line));\nif (rest.length) out.push('*Tags only:*', ...rest.slice(0, 20).map(p => p.line));\nif (rest.length > 20) out.push(`…and ${rest.length - 20} more`);\nif (errors.length) out.push('*Errors:*', ...errors.slice(0, 10).map(e => '• ' + e));\nif (throttled) out.push(`Throttled retries: ${throttled}`);\nconst cfg = $('Config').first().json;\nconst always = cfg.notifyEveryRun === true || String(cfg.notifyEveryRun) === 'true';\nreturn [{ json: { notify: alerts.length > 0 || errors.length > 0 || always, text: out.join('\\n'),\n  tagged: done.length, alerts: alerts.length, errors: errors.length, throttledRetries: throttled } }];\n"}, "name": "Check results", "type": "n8n-nodes-base.code", "typeVersion": 2, "position": [1980, 400], "id": "0f7a1c00-0000-4000-8000-000000000015"},
  {"parameters": {"conditions": {"options": {"caseSensitive": true, "leftValue": "", "typeValidation": "strict", "version": 2}, "conditions": [{"id": "c1", "leftValue": "={{ $json.notify }}", "rightValue": "", "operator": {"type": "boolean", "operation": "true", "singleValue": true}}], "combinator": "and"}, "options": {}}, "name": "Anything to report?", "type": "n8n-nodes-base.filter", "typeVersion": 2.2, "position": [2200, 280], "id": "0f7a1c00-0000-4000-8000-000000000016"},
  {"parameters": {"method": "POST", "url": "={{ $('Config').first().json.slackWebhookUrl }}", "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify({ text: $json.text }) }}", "options": {}}, "name": "Send Slack report", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [2420, 280], "retryOnFail": true, "maxTries": 3, "waitBetweenTries": 5000, "id": "0f7a1c00-0000-4000-8000-000000000017"},
  {"parameters": {}, "name": "On workflow error", "type": "n8n-nodes-base.errorTrigger", "typeVersion": 1, "position": [0, 580], "id": "0f7a1c00-0000-4000-8000-000000000018"},
  {"parameters": {"method": "POST", "url": "https://hooks.slack.com/services/XXX/YYY/ZZZ", "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify({ text: `:warning: *${$json.workflow.name}* failed in node *${$json.execution.lastNodeExecuted || '?'}*\\n${($json.execution.error || {}).message || 'Unknown error'}\\n${$json.execution.url || ''}` }) }}", "options": {}}, "name": "Slack error alert", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [220, 580], "id": "0f7a1c00-0000-4000-8000-000000000019"}
 ],
 "connections": {"Every 15 minutes": {"main": [[{"node": "Config", "type": "main", "index": 0}]]}, "Run manually": {"main": [[{"node": "Config", "type": "main", "index": 0}]]}, "Config": {"main": [[{"node": "Get Shopify token", "type": "main", "index": 0}]]}, "Get Shopify token": {"main": [[{"node": "Build order query", "type": "main", "index": 0}]]}, "Build order query": {"main": [[{"node": "Fetch recent orders", "type": "main", "index": 0}]]}, "Fetch recent orders": {"main": [[{"node": "Decide tags", "type": "main", "index": 0}]]}, "Decide tags": {"main": [[{"node": "Dry run or nothing to tag?", "type": "main", "index": 0}]]}, "Dry run or nothing to tag?": {"main": [[{"node": "Anything to report?", "type": "main", "index": 0}], [{"node": "Split into API batches", "type": "main", "index": 0}]]}, "Split into API batches": {"main": [[{"node": "Add tags in Shopify", "type": "main", "index": 0}]]}, "Add tags in Shopify": {"main": [[{"node": "Check results", "type": "main", "index": 0}]]}, "Check results": {"main": [[{"node": "Anything to report?", "type": "main", "index": 0}]]}, "Anything to report?": {"main": [[{"node": "Send Slack report", "type": "main", "index": 0}]]}, "On workflow error": {"main": [[{"node": "Slack error alert", "type": "main", "index": 0}]]}},
 "settings": {"executionOrder": "v1"},
 "pinData": {}
}

My products, if you'd rather not build this yourself:

Tikkivo Catalog Sync is a Shopify app that keeps supplier stock and prices in sync.
My Gumroad store has more n8n templates for Shopify.

The free workflow above works on its own either way. Questions are welcome in the comments.

Note: I used AI tools to help draft this post. Test the workflow in dry-run/test mode on a development store before using it on a live one.

A free n8n template to sync supplier stock and prices to Shopify (with dry-run mode)

Arturas Tikkivo — Tue, 27 Oct 2026 17:43:42 +0000

Most small Shopify stores that resell or dropship have the same weekly chore. The supplier publishes a stock and price file, someone downloads it, and someone types the numbers into Shopify. Or they don't, and the store sells something the supplier ran out of on Tuesday.

I build Shopify apps and n8n automations, and this is the workflow I wish I'd had the first time a client asked for it. It's a full template, not a demo: 15 nodes plus setup notes, a dry-run mode that's on by default, and the safety checks I ended up needing. You can import it below for free.

What it does

Every 6 hours (or when you click Execute workflow):

Config holds the shop URL, location, feed URL, column names and pricing rules.
Get Shopify token swaps your app's client ID and secret for a 24-hour Admin API token. It's the same approach as in my low-stock alert post, so the secret stays in an n8n credential.
Download supplier feed fetches a CSV or JSON file over HTTP.
Fetch Shopify variants reads every variant with its SKU, price and available stock at your location, page by page.
Build sync plan matches feed rows to variants by SKU, calculates the selling price from cost, and works out exactly what differs.
If dryRun is on, it only reports. If it's off, Send updates to Shopify writes the changes in batches, and Check results counts what Shopify actually accepted.
A Slack summary shows the counts: changed, unchanged, unmatched, skipped and errors.
A built-in error branch posts to Slack when a production run fails.

It only ever touches stock and price. It never creates, edits or deletes a product, and titles, descriptions and images are never sent at all.

Setup (about 10 minutes)

In Shopify's Dev Dashboard, create an app with the read_products, write_products, read_inventory and write_inventory scopes. Install it on your store and copy the client ID and secret.
In n8n, create a Custom Auth credential with {"body": {"client_id": "…", "client_secret": "…"}}. Select it in Get Shopify token.
Open Config and fill in your values. To get locationId, go to Settings → Locations, open the location and take the number at the end of the URL: gid://shopify/Location/<number>. Set skuColumn, stockColumn and costColumn to the header names exactly as they appear in the supplier's file.
Paste your Slack incoming-webhook URL into Config and into the Slack error alert node. The error branch runs as a separate execution, so it can't read Config.
In Workflow settings → Error workflow, pick this same workflow. The Error Trigger lives inside it.
Run it with dryRun = true and read the report. When the numbers look right, set dryRun = false and activate it.

If your feed needs a login, add a Header Auth, Basic Auth or Query Auth credential to Download supplier feed rather than putting a password in Config.

Older store apps with a permanent shpat_ token: delete Get Shopify token. Set the two Shopify HTTP nodes to Header Auth with a credential X-Shopify-Access-Token: shpat_…, and remove the token header row.

How matching works

SKU is the only key. Real feeds are messy. Mine had sup-1005 with a trailing space and lower case, which doesn't match SUP-1005. The plan node trims and upper-cases both sides before comparing.

Then it sorts every variant into a bucket:

Matched: the SKU is in the feed. Its stock and price are compared with Shopify.
Not in feed: the SKU is in Shopify but not in the feed. If zeroMissingSkus is on, its stock is set to 0, because the supplier dropped it. If it's off, it's left alone.
In feed but not in Shopify: products you haven't listed. They're reported only. A sync should never create products behind your back.
Skipped: no SKU, a SKU outside your skuPrefix, "don't track quantity", not stocked at the chosen location, or a duplicate SKU in Shopify. Duplicates are never guessed. If two variants share a SKU, neither gets touched, and the report tells you.

skuPrefix matters more than it looks. If your store mixes supplier items (SUP-…) with your own products, set it to SUP-. Then "not in feed → 0" can never hit your own stock.

How the price rule works

price = cost × markup
price = max(price, cost / (1 − minMarginPercent / 100))
price = round UP to the next .99   (priceEnding = 0.99, or -1 to just round to cents)

Some examples with markup = 2.2:

Cost 8,40 → 18.48 → 18.99
Cost 11,00 → 24.20 → 24.99. That's what the store already had, so nothing is written.

The minimum margin kicks in when you use a low markup. With markup 1.3 and cost 10.00 you get 13.00, which is only a 23% margin. With minMarginPercent = 35 it becomes 15.38, rounded up to 15.99.

Rounding goes up on purpose. Rounding 18.48 down to 17.99 would quietly eat your margin.

There's also maxPriceChangePercent (default 50). Suppliers make typos. In one of my test feeds, a cost of 18.20 became 180.0, which would have priced a 38.99 vase at 396.99. Any change bigger than the limit is held for review in the Slack report and not written. stockBuffer subtracts a safety margin from the supplier's stock, so you're not selling their last unit.

Dry run

dryRun is true in the template. In dry-run mode the plan is built in full, but the IF node sends it straight to Slack. A real report from one of my runs looks like this:

*Supplier → Shopify sync* — DRY RUN, nothing was written
Feed: 8 rows · Shopify: 10 variants · managed: 9 · matched: 7
Would change: 5 stock, 6 price · unchanged: 1
Not in feed: 2 (SUP-1007, OWN-001), 1 set to 0
In feed but not in Shopify: 1 (SUP-2000)
Skipped: no SKU 1, not tracked 1, not stocked at location 1
*Changes:*
• SUP-1001 Linen Napkin Set - Natural: stock 10 → 25, price 19.99 → 18.99
• SUP-1003 Ceramic Vase - Small: stock 0 → 6
• SUP-1007 Candle Trio - Default Title: not in feed, stock 12 → 0

Run the same feed again in live mode and nothing is written. If nothing changed, no Slack message goes out either, unless you turn on notifyWhenNothingChanged.

The gotchas (the reason this took longer than an afternoon)

I built and ran it against a test Shopify API on n8n 2.44.5. These are the things that bit me, plus one API change you need to know about.

1. "Throttled" arrives as HTTP 200

Shopify's GraphQL API limits you by query cost. When you're over, you can get HTTP 200 with errors[].extensions.code = "THROTTLED". n8n's Retry on fail never fires, because nothing technically failed.

I use the HTTP node's pagination as a retry loop. For reads, the pagination expression keeps the same cursor when a page was throttled. It also refuses to "complete" on a throttled response:

// Pagination parameter (body → variables)
{{ { after: $response.body.data ? $response.body.data.productVariants.pageInfo.endCursor
                                : $request.body.variables.after,
     loc: $('Config').first().json.locationId } }}

// Complete when (Other)
{{ JSON.stringify($response.body.errors || '').includes('THROTTLED') ? false
   : !($response.body.data && $response.body.data.productVariants.pageInfo.hasNextPage) }}

For writes, the same trick works by updating a dummy X-Attempt header. Pagination finishes when the response is not throttled, with at most 6 tries and 2 seconds between them.

That cursor detail matters more here than in an alert workflow. If a throttled page silently ended the loop, you'd get half your variants. Everything on the missing half would then look "not in feed" and be set to 0. So the plan node also checks that the last page has hasNextPage: false. If it doesn't, it stops before writing anything.

2. API 2026-04 changed inventorySetQuantities

From API version 2026-04, inventorySetQuantities requires two things. Every quantity needs a changeFromQuantity, and the mutation needs an @idempotent(key: …) directive. Without them, old snippets from blog posts fail.

Both are actually useful:

mutation SetStock($input: InventorySetQuantitiesInput!, $key: String!) {
  b0: inventorySetQuantities(input: $input) @idempotent(key: $key) {
    inventoryAdjustmentGroup { changes { name delta } }
    userErrors { code field message }
  }
}

changeFromQuantity is the stock the workflow read a moment ago. If an order comes in between the read and the write, Shopify answers CHANGE_FROM_QUANTITY_STALE instead of overwriting the sale. The report lists it as an error, and the next run fixes it with fresh numbers. I tested exactly that case.

The idempotency key is built from the execution ID and the batch number. A throttled retry sends the identical body, so it can't apply twice.

Prices go through productVariantsBulkUpdate, which takes one product at a time. The workflow puts up to 10 products in one request using GraphQL aliases. Stock goes in batches of 100 quantities.

3. Don't trust item order after an HTTP node with retries

With pagination as a retry loop, one batch can produce three output items: two throttled and one real. I first used pairedItem to map responses back to batches. In my runs, inside the Code node, it pointed at response positions instead, so the report said "0 updated" when everything had worked.

The fix is to give every batch its own GraphQL alias (b0, b1_u0, b1_u1…). The alias comes back in the response, so Check results knows which batch each result belongs to. It counts what Shopify says changed, not what was requested.

4. European CSVs

Supplier files from EU wholesalers are often semicolon-separated, use decimal commas (8,40, "1.234,50"), and start with an Excel BOM. The parser auto-detects ;, ,, tab and |. It strips the BOM, handles quoted fields, and reads both 1.234,50 and 1,234.50. A stock value of >100 becomes 100.

If a column name is wrong, the run stops with a message listing the real headers, for example Column "Item No" not found in feed. Columns are: SKU, Name, Stock, Price. That beats a silent "0 matched".

5. A broken feed must not empty your store

Feeds break: an empty file, a login page instead of a CSV, a half-uploaded export. With "missing → 0" turned on, that could zero your whole catalog.

maxZeroPercent (default 30) is a hard stop. When I fed the workflow a file containing only unknown SKUs, it refused: Safety stop: 7 of 7 stock-tracked variants are missing from the feed and would be set to 0 (limit 30%). It wrote nothing, and the error branch sent the alert.

A few n8n habits that helped

Keep decisions in one Code node and keep the HTTP nodes dumb. Then the dry run and the live run share 100% of the logic.
Pin the feed and variant outputs while you tweak pricing rules, so you're not downloading the feed on every click. Unpin before you activate.
The 24-hour access token appears in saved execution data. If that bothers you, turn off saving of successful executions in the workflow settings.

Limits

It syncs one location per workflow. For two warehouses, duplicate the workflow and change locationId. It doesn't do compare-at prices, currency conversion or variant creation. Always start with a development store and dry-run mode.

The template

In n8n, open a new workflow and paste this with Ctrl/Cmd+V, or save it as a .json file and use Import from file.

{
 "name": "Supplier feed → Shopify stock & price sync (free, by Tikkivo)",
 "nodes": [
  {"id": "5f0c1e2a-0002-4000-8000-000000000101", "name": "Sticky: setup", "type": "n8n-nodes-base.stickyNote", "typeVersion": 1, "position": [-460, -420], "parameters": {"content": "## Supplier feed → Shopify stock & price sync\n**Free template by Arturas (Tikkivo)**\n\nEvery 6 hours: downloads your supplier's CSV/JSON feed, matches rows to Shopify variants by **SKU**, and updates **only the stock and prices that changed**. It never creates, edits or deletes products, titles, images or descriptions.\n\n### Setup (10 min)\n1. Shopify **Dev Dashboard** → create an app with scopes `read_products, write_products, read_inventory, write_inventory`, install it on your store, copy client ID + secret.\n2. n8n → Credentials → **Custom Auth**:\n`{\"body\": {\"client_id\": \"…\", \"client_secret\": \"…\"}}`\nSelect it in **Get Shopify token**.\n3. Fill in **Config** (shop URL, location ID, feed URL, column names, markup, Slack webhook).\n4. Paste the Slack webhook URL in **Slack error alert** too.\n5. Workflow settings → **Error workflow** → choose *this workflow*.\n6. Run with `dryRun = true`, read the Slack report, then set `dryRun = false` and activate.", "width": 420, "height": 760, "color": 4}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000102", "name": "Sticky: config", "type": "n8n-nodes-base.stickyNote", "typeVersion": 1, "position": [-20, -420], "parameters": {"content": "### Config cheat sheet\n- **locationId**: Settings → Locations → open one → the number in the URL → `gid://shopify/Location/<number>`\n- **dryRun** (default ON): only reports, writes nothing\n- **skuColumn / stockColumn / costColumn**: header names exactly as in the feed\n- **csvDelimiter**: empty = auto (`;` `,` tab `|`). Decimal commas like `8,40` are handled\n- **skuPrefix**: only manage SKUs starting with this (e.g. `SUP-`). Empty = all\n- **price** = cost × markup, then at least `minMarginPercent` margin, then rounded *up* to `priceEnding` (.99). `-1` = round to cents\n- **maxPriceChangePercent**: bigger jumps are held for review, not written\n- **stockBuffer**: subtract this from supplier stock (safety stock)\n- **zeroMissingSkus**: SKUs not in the feed → stock 0\n- **maxZeroPercent**: safety stop if a broken feed would zero more than this share of variants\n\nSecrets live in n8n **credentials**, not here.", "width": 420, "height": 600, "color": 7}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000103", "name": "Sticky: legacy token", "type": "n8n-nodes-base.stickyNote", "typeVersion": 1, "position": [420, -420], "parameters": {"content": "### Old store app with a `shpat_` token?\nDelete **Get Shopify token**. In **Fetch Shopify variants** and **Send updates to Shopify** switch Authentication to *Generic → Header Auth* with a credential `X-Shopify-Access-Token: shpat_…`, and remove the token header row.\n\n### Feed needs a login?\nAdd a Header Auth / Basic Auth / Query Auth credential to **Download supplier feed**. Don't put passwords in Config.", "width": 400, "height": 300, "color": 5}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000104", "name": "Sticky: safety", "type": "n8n-nodes-base.stickyNote", "typeVersion": 1, "position": [1080, -420], "parameters": {"content": "### Safety built in\n- Writes only what differs from Shopify right now\n- Stock writes use `changeFromQuantity` (compare-and-swap) + an idempotency key, so a sale in between is not overwritten and a retry can't double-apply\n- Throttled responses (HTTP 200 + `THROTTLED`) are retried by the pagination settings, up to 6 tries\n- Incomplete variant list, missing columns, empty feed or too many zeroes → the run stops **before** writing\n- Duplicate SKUs in Shopify are skipped, never guessed", "width": 460, "height": 300, "color": 6}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000105", "name": "Sticky: errors", "type": "n8n-nodes-base.stickyNote", "typeVersion": 1, "position": [-20, 460], "parameters": {"content": "### Error alerts\nRuns when any production execution fails (set it under Workflow settings → Error workflow). Paste your Slack webhook URL in the node.", "width": 420, "height": 200, "color": 3}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000001", "name": "Every 6 hours", "type": "n8n-nodes-base.scheduleTrigger", "typeVersion": 1.2, "position": [0, 200], "parameters": {"rule": {"interval": [{"field": "hours", "hoursInterval": 6}]}}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000002", "name": "Run manually", "type": "n8n-nodes-base.manualTrigger", "typeVersion": 1, "position": [0, 360], "parameters": {}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000003", "name": "Config", "type": "n8n-nodes-base.set", "typeVersion": 3.4, "position": [220, 280], "parameters": {"assignments": {"assignments": [{"id": "cfg1", "name": "shopUrl", "value": "https://your-store.myshopify.com", "type": "string"}, {"id": "cfg2", "name": "apiVersion", "value": "2026-10", "type": "string"}, {"id": "cfg3", "name": "locationId", "value": "gid://shopify/Location/REPLACE_ME", "type": "string"}, {"id": "cfg4", "name": "dryRun", "value": true, "type": "boolean"}, {"id": "cfg5", "name": "feedUrl", "value": "https://supplier.example.com/stock.csv", "type": "string"}, {"id": "cfg6", "name": "feedFormat", "value": "csv", "type": "string"}, {"id": "cfg7", "name": "csvDelimiter", "value": "", "type": "string"}, {"id": "cfg8", "name": "jsonItemsKey", "value": "items", "type": "string"}, {"id": "cfg9", "name": "skuColumn", "value": "Item No", "type": "string"}, {"id": "cfg10", "name": "stockColumn", "value": "Qty available", "type": "string"}, {"id": "cfg11", "name": "costColumn", "value": "Net price EUR", "type": "string"}, {"id": "cfg12", "name": "skuPrefix", "value": "", "type": "string"}, {"id": "cfg13", "name": "updateStock", "value": true, "type": "boolean"}, {"id": "cfg14", "name": "updatePrices", "value": true, "type": "boolean"}, {"id": "cfg15", "name": "markup", "value": 2.2, "type": "number"}, {"id": "cfg16", "name": "priceEnding", "value": 0.99, "type": "number"}, {"id": "cfg17", "name": "minMarginPercent", "value": 35, "type": "number"}, {"id": "cfg18", "name": "maxPriceChangePercent", "value": 50, "type": "number"}, {"id": "cfg19", "name": "stockBuffer", "value": 0, "type": "number"}, {"id": "cfg20", "name": "zeroMissingSkus", "value": true, "type": "boolean"}, {"id": "cfg21", "name": "maxZeroPercent", "value": 30, "type": "number"}, {"id": "cfg22", "name": "inventoryReason", "value": "correction", "type": "string"}, {"id": "cfg23", "name": "slackWebhookUrl", "value": "https://hooks.slack.com/services/XXX/YYY/ZZZ", "type": "string"}, {"id": "cfg24", "name": "notifyWhenNothingChanged", "value": false, "type": "boolean"}]}, "options": {}}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000004", "name": "Get Shopify token", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [440, 280], "credentials": {"httpCustomAuth": {"id": "shopifyAppSync001", "name": "Shopify app (client id + secret)"}}, "parameters": {"method": "POST", "url": "={{ $json.shopUrl }}/admin/oauth/access_token", "authentication": "genericCredentialType", "genericAuthType": "httpCustomAuth", "sendBody": true, "specifyBody": "json", "jsonBody": "{ \"grant_type\": \"client_credentials\" }", "options": {}}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000005", "name": "Download supplier feed", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [660, 280], "parameters": {"url": "={{ $('Config').first().json.feedUrl }}", "options": {"response": {"response": {"responseFormat": "text", "outputPropertyName": "data"}}, "timeout": 120000}}, "retryOnFail": true, "maxTries": 3, "waitBetweenTries": 5000},
  {"id": "5f0c1e2a-0002-4000-8000-000000000006", "name": "Fetch Shopify variants", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [880, 280], "parameters": {"method": "POST", "url": "={{ $('Config').first().json.shopUrl }}/admin/api/{{ $('Config').first().json.apiVersion }}/graphql.json", "sendHeaders": true, "headerParameters": {"parameters": [{"name": "X-Shopify-Access-Token", "value": "={{ $('Get Shopify token').first().json.access_token }}"}]}, "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify({ query: \"query Variants($after: String, $loc: ID!) { productVariants(first: 100, after: $after) { pageInfo { hasNextPage endCursor } nodes { id sku displayName price product { id status } inventoryItem { id tracked inventoryLevel(locationId: $loc) { quantities(names: [\\\"available\\\"]) { name quantity } } } } } }\", variables: { after: null, loc: $('Config').first().json.locationId } }) }}", "options": {"pagination": {"pagination": {"parameters": {"parameters": [{"type": "body", "name": "variables", "value": "={{ { after: $response.body.data ? $response.body.data.productVariants.pageInfo.endCursor : $request.body.variables.after, loc: $('Config').first().json.locationId } }}"}]}, "paginationCompleteWhen": "other", "completeExpression": "={{ JSON.stringify($response.body.errors || '').includes('THROTTLED') ? false : !($response.body.data && $response.body.data.productVariants && $response.body.data.productVariants.pageInfo.hasNextPage) }}", "limitPagesFetched": true, "maxRequests": 300, "requestInterval": 1000}}}}, "retryOnFail": true, "maxTries": 3, "waitBetweenTries": 5000},
  {"id": "5f0c1e2a-0002-4000-8000-000000000007", "name": "Build sync plan", "type": "n8n-nodes-base.code", "typeVersion": 2, "position": [1100, 280], "parameters": {"jsCode": "// Build sync plan: parse feed -> match Shopify variants by SKU -> decide what to change.\n// Nothing is written here. Writes only happen in \"Send updates to Shopify\" when dryRun is false.\nconst cfg = $('Config').first().json;\nconst bool = v => v === true || String(v).trim().toLowerCase() === 'true';\nconst num = (v, d) => (v === '' || v == null || isNaN(Number(v))) ? d : Number(v);\nconst normSku = s => String(s ?? '').trim().toUpperCase();\n\nconst dryRun = bool(cfg.dryRun);\nconst markup = num(cfg.markup, 2);\nconst priceEnding = num(cfg.priceEnding, 0.99);      // -1 = just round to cents\nconst minMargin = num(cfg.minMarginPercent, 0);\nconst maxPriceChange = num(cfg.maxPriceChangePercent, 50);\nconst stockBuffer = num(cfg.stockBuffer, 0);\nconst maxZeroPct = num(cfg.maxZeroPercent, 30);\nconst prefix = normSku(cfg.skuPrefix);\nif (!String(cfg.locationId).startsWith('gid://shopify/Location/'))\n  throw new Error('Config.locationId must look like gid://shopify/Location/123456789');\n\n// ---------- 1. Parse the supplier feed (CSV or JSON) ----------\nfunction parseCsv(text, delim) {\n  text = text.replace(/^\\uFEFF/, '');                       // Excel BOM\n  const first = text.split(/\\r?\\n/, 1)[0];\n  if (!delim) {                                              // auto-detect ; , tab |\n    const c = d => first.split(d).length;\n    delim = [';', ',', '\\t', '|'].sort((a, b) => c(b) - c(a))[0];\n  }\n  const rows = []; let row = [], f = '', q = false;\n  for (let i = 0; i < text.length; i++) {\n    const ch = text[i];\n    if (q) { if (ch === '\"') { if (text[i + 1] === '\"') { f += '\"'; i++; } else q = false; } else f += ch; }\n    else if (ch === '\"') q = true;\n    else if (ch === delim) { row.push(f); f = ''; }\n    else if (ch === '\\n' || ch === '\\r') {\n      if (ch === '\\r' && text[i + 1] === '\\n') i++;\n      row.push(f); f = ''; if (row.some(x => x.trim() !== '')) rows.push(row); row = [];\n    } else f += ch;\n  }\n  row.push(f); if (row.some(x => x.trim() !== '')) rows.push(row);\n  const head = (rows.shift() || []).map(h => h.trim());\n  return rows.map(r => Object.fromEntries(head.map((h, i) => [h, (r[i] ?? '').trim()])));\n}\nfunction parseNum(v) {                                       // \"8,40\" \"1.234,50\" \"€ 12.00\" \"1,234.50\"\n  if (typeof v === 'number') return v;\n  let s = String(v ?? '').replace(/[^\\d,.\\-]/g, '');\n  if (!s) return NaN;\n  const lc = s.lastIndexOf(','), ld = s.lastIndexOf('.');\n  if (lc > -1 && ld > -1) s = lc > ld ? s.replace(/\\./g, '').replace(',', '.') : s.replace(/,/g, '');\n  else if (lc > -1) s = (s.split(',').length === 2) ? s.replace(',', '.') : s.replace(/,/g, '');\n  return Number(s);\n}\nconst raw = $('Download supplier feed').first().json.data;\nlet rows;\nif (String(cfg.feedFormat).toLowerCase() === 'json') {\n  const j = typeof raw === 'string' ? JSON.parse(raw) : raw;\n  rows = Array.isArray(j) ? j : (j[cfg.jsonItemsKey] || Object.values(j).find(Array.isArray) || []);\n} else {\n  rows = parseCsv(String(raw ?? ''), cfg.csvDelimiter || '');\n}\nif (!rows.length) throw new Error('Supplier feed has no rows. Nothing was changed.');\nfor (const col of [cfg.skuColumn, cfg.stockColumn, cfg.costColumn])\n  if (!(col in rows[0])) throw new Error(`Column \"${col}\" not found in feed. Columns are: ${Object.keys(rows[0]).join(', ')}`);\n\nconst feed = new Map(); let feedDuplicates = 0, feedBadRows = 0;\nfor (const r of rows) {\n  const sku = normSku(r[cfg.skuColumn]);\n  if (!sku) { feedBadRows++; continue; }\n  if (feed.has(sku)) { feedDuplicates++; continue; }        // first row wins\n  const stockRaw = parseInt(String(r[cfg.stockColumn] ?? '').replace(/[^\\d\\-]/g, ''), 10);\n  const cost = parseNum(r[cfg.costColumn]);\n  if (isNaN(stockRaw) && !(cost > 0)) { feedBadRows++; continue; }\n  feed.set(sku, { stock: isNaN(stockRaw) ? null : Math.max(0, stockRaw - stockBuffer), cost: cost > 0 ? cost : null });\n}\n\n// ---------- 2. Collect every Shopify variant (all pages) ----------\nconst variants = []; let lastPage = null, throttledPages = 0;\nfor (const { json: p } of $('Fetch Shopify variants').all()) {\n  if (JSON.stringify(p.errors || '').includes('THROTTLED')) { throttledPages++; continue; }   // retried by pagination\n  if (p.errors) throw new Error('Shopify GraphQL error: ' + JSON.stringify(p.errors).slice(0, 500));\n  variants.push(...p.data.productVariants.nodes); lastPage = p;\n}\nif (!lastPage || lastPage.data.productVariants.pageInfo.hasNextPage)\n  throw new Error('Shopify variant list is incomplete (page limit or throttling). Nothing was changed.');\n\n// ---------- 3. Price rule ----------\nfunction sellPrice(cost) {\n  let p = cost * markup;\n  if (minMargin > 0) p = Math.max(p, cost / (1 - minMargin / 100));   // margin = (price - cost) / price\n  const floor = p;\n  if (priceEnding >= 0) { p = Math.floor(p) + priceEnding; if (p < floor - 1e-9) p += 1; }\n  return Math.round(p * 100) / 100;\n}\n\n// ---------- 4. Match by SKU and decide ----------\nconst count = new Map();\nfor (const v of variants) { const s = normSku(v.sku); if (s) count.set(s, (count.get(s) || 0) + 1); }\nconst s = { feedRows: rows.length, feedSkus: feed.size, feedDuplicates, feedBadRows, scanned: variants.length,\n  pages: variants.length ? $('Fetch Shopify variants').all().length - throttledPages : 0, throttledPages,\n  managed: 0, matched: 0, unchanged: 0, stockChanges: 0, priceChanges: 0, zeroedMissing: 0, missingFromFeed: 0,\n  stockable: 0, missingStockable: 0, noSku: 0, outsidePrefix: 0, duplicateSkus: 0, notTracked: 0, notStocked: 0, priceHeld: 0, unmatchedFeed: 0 };\nconst stock = [], prices = [], preview = [], held = [], missing = [];\nfor (const v of variants) {\n  const sku = normSku(v.sku);\n  if (!sku) { s.noSku++; continue; }\n  if (prefix && !sku.startsWith(prefix)) { s.outsidePrefix++; continue; }\n  if (count.get(sku) > 1) { s.duplicateSkus++; continue; }  // ambiguous: never guess\n  s.managed++;\n  const lvl = v.inventoryItem && v.inventoryItem.inventoryLevel;\n  const qtyNow = lvl ? (lvl.quantities.find(q => q.name === 'available') || {}).quantity : null;\n  const canStock = bool(cfg.updateStock) && v.inventoryItem && v.inventoryItem.tracked && lvl;\n  if (bool(cfg.updateStock) && v.inventoryItem && !v.inventoryItem.tracked) s.notTracked++;\n  else if (bool(cfg.updateStock) && !lvl) s.notStocked++;\n  if (canStock) s.stockable++;\n  const f = feed.get(sku); let changed = false, line = `• ${sku} ${v.displayName}:`;\n  if (!f) {\n    s.missingFromFeed++; missing.push(sku); if (canStock) s.missingStockable++;\n    if (bool(cfg.zeroMissingSkus) && canStock && qtyNow !== 0) {\n      stock.push({ inventoryItemId: v.inventoryItem.id, locationId: cfg.locationId, quantity: 0, changeFromQuantity: qtyNow });\n      s.zeroedMissing++; s.stockChanges++; preview.push(`${line} not in feed, stock ${qtyNow} → 0`);\n    } else s.unchanged++;\n    continue;\n  }\n  s.matched++;\n  if (canStock && f.stock !== null && f.stock !== qtyNow) {\n    stock.push({ inventoryItemId: v.inventoryItem.id, locationId: cfg.locationId, quantity: f.stock, changeFromQuantity: qtyNow });\n    s.stockChanges++; changed = true; line += ` stock ${qtyNow} → ${f.stock}`;\n  }\n  if (bool(cfg.updatePrices) && f.cost) {\n    const now = Number(v.price), next = sellPrice(f.cost);\n    if (Math.abs(next - now) >= 0.005) {\n      const pct = now > 0 ? Math.abs(next - now) / now * 100 : 100;\n      if (pct > maxPriceChange) { s.priceHeld++; held.push(`• ${sku}: ${now.toFixed(2)} → ${next.toFixed(2)} (${pct.toFixed(0)}%) held for review`); }\n      else { prices.push({ productId: v.product.id, id: v.id, price: next.toFixed(2) }); s.priceChanges++; changed = true; line += `${line.endsWith(':') ? '' : ','} price ${now.toFixed(2)} → ${next.toFixed(2)}`; }\n    }\n  }\n  if (changed) preview.push(line); else s.unchanged++;\n}\nconst shopSkus = new Set(variants.map(v => normSku(v.sku)));\nconst unmatched = [...feed.keys()].filter(k => !shopSkus.has(k)); s.unmatchedFeed = unmatched.length;\n\n// Safety valve: a broken or half-empty feed must not wipe out the store's stock.\nif (bool(cfg.zeroMissingSkus) && s.stockable && s.missingStockable / s.stockable * 100 > maxZeroPct)\n  throw new Error(`Safety stop: ${s.missingStockable} of ${s.stockable} stock-tracked variants are missing from the feed and would be set to 0 (limit ${maxZeroPct}%). Check the feed. Nothing was changed.`);\n\n// ---------- 5. Batch the writes ----------\nconst runId = $execution.id;\n// Every batch gets its own alias (b0, b1_u0 ...) so results can be matched back even after throttled retries.\nconst batches = [];\nfor (let i = 0; i < stock.length; i += 100) batches.push({ kind: 'stock', count: Math.min(100, stock.length - i), body: {\n  query: `mutation SetStock($input: InventorySetQuantitiesInput!, $key: String!) { b${batches.length}: inventorySetQuantities(input: $input) @idempotent(key: $key) { inventoryAdjustmentGroup { changes { name delta } } userErrors { code field message } } }`,\n  variables: { input: { name: 'available', reason: cfg.inventoryReason || 'correction', referenceDocumentUri: `n8n://supplier-sync/${runId}`,\n    quantities: stock.slice(i, i + 100) }, key: `supplier-sync-${runId}-stock-${i / 100}` } } });\nconst byProduct = {};\nfor (const p of prices) (byProduct[p.productId] = byProduct[p.productId] || []).push({ id: p.id, price: p.price });\nconst products = Object.entries(byProduct);\nfor (let i = 0; i < products.length; i += 10) {\n  const chunk = products.slice(i, i + 10), vars = {}, defs = [], ops = [], b = batches.length;\n  chunk.forEach(([pid, vs], k) => { vars['p' + k] = pid; vars['v' + k] = vs; defs.push(`$p${k}: ID!, $v${k}: [ProductVariantsBulkInput!]!`);\n    ops.push(`b${b}_u${k}: productVariantsBulkUpdate(productId: $p${k}, variants: $v${k}) { productVariants { id price } userErrors { field message } }`); });\n  batches.push({ kind: 'price', count: chunk.reduce((n, [, vs]) => n + vs.length, 0), body: { query: `mutation SetPrices(${defs.join(', ')}) { ${ops.join(' ')} }`, variables: vars } });\n}\n\nconst changes = s.stockChanges + s.priceChanges;\nconst list = (arr, n = 10) => arr.slice(0, n).join(', ') + (arr.length > n ? ` (+${arr.length - n} more)` : '');\nconst lines = [\n  `*Supplier → Shopify sync* ${dryRun ? '— DRY RUN, nothing was written' : ''}`,\n  `Feed: ${s.feedRows} rows · Shopify: ${s.scanned} variants · managed: ${s.managed} · matched: ${s.matched}`,\n  `${dryRun ? 'Would change' : 'Planned'}: ${s.stockChanges} stock, ${s.priceChanges} price · unchanged: ${s.unchanged}`,\n];\nif (s.missingFromFeed) lines.push(`Not in feed: ${s.missingFromFeed} (${list(missing)})${bool(cfg.zeroMissingSkus) ? (s.zeroedMissing ? `, ${s.zeroedMissing} set to 0` : ', already 0 or not stock-tracked') : ', left alone'}`);\nif (s.unmatchedFeed) lines.push(`In feed but not in Shopify: ${s.unmatchedFeed} (${list(unmatched)})`);\nconst skipped = [['no SKU', s.noSku], ['other prefix', s.outsidePrefix], ['duplicate SKU', s.duplicateSkus], ['not tracked', s.notTracked], ['not stocked at location', s.notStocked], ['bad feed rows', s.feedBadRows], ['duplicate feed rows', s.feedDuplicates]].filter(x => x[1]);\nif (throttledPages) lines.push(`Shopify throttled ${throttledPages} read request(s); they were retried.`);\nif (skipped.length) lines.push('Skipped: ' + skipped.map(([k, n]) => `${k} ${n}`).join(', '));\nif (held.length) lines.push(`*Price changes over ${maxPriceChange}% held for review:*\\n` + held.slice(0, 10).join('\\n'));\nif (preview.length) lines.push('*Changes:*\\n' + preview.slice(0, 15).join('\\n') + (preview.length > 15 ? `\\n…and ${preview.length - 15} more` : ''));\n\nreturn [{ json: { dryRun, batchCount: dryRun ? 0 : batches.length, batches: dryRun ? [] : batches, summary: s,\n  notify: dryRun || changes > 0 || held.length > 0 || bool(cfg.notifyWhenNothingChanged), text: lines.join('\\n') } }];\n"}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000008", "name": "Dry run or nothing to write?", "type": "n8n-nodes-base.if", "typeVersion": 2.2, "position": [1320, 280], "parameters": {"conditions": {"options": {"caseSensitive": true, "leftValue": "", "typeValidation": "strict", "version": 2}, "conditions": [{"id": "c1", "leftValue": "={{ $json.dryRun || $json.batchCount === 0 }}", "rightValue": "", "operator": {"type": "boolean", "operation": "true", "singleValue": true}}], "combinator": "and"}, "options": {}}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000009", "name": "Split into API batches", "type": "n8n-nodes-base.splitOut", "typeVersion": 1, "position": [1540, 380], "parameters": {"fieldToSplitOut": "batches", "options": {}}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000010", "name": "Send updates to Shopify", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [1760, 380], "parameters": {"method": "POST", "url": "={{ $('Config').first().json.shopUrl }}/admin/api/{{ $('Config').first().json.apiVersion }}/graphql.json", "sendHeaders": true, "headerParameters": {"parameters": [{"name": "X-Shopify-Access-Token", "value": "={{ $('Get Shopify token').first().json.access_token }}"}]}, "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify($json.body) }}", "options": {"batching": {"batch": {"batchSize": 1, "batchInterval": 1000}}, "pagination": {"pagination": {"parameters": {"parameters": [{"type": "headers", "name": "X-Attempt", "value": "={{ $pageCount + 1 }}"}]}, "paginationCompleteWhen": "other", "completeExpression": "={{ !(JSON.stringify($response.body.errors || '').includes('THROTTLED')) }}", "limitPagesFetched": true, "maxRequests": 6, "requestInterval": 2000}}}}, "retryOnFail": true, "maxTries": 2, "waitBetweenTries": 5000},
  {"id": "5f0c1e2a-0002-4000-8000-000000000011", "name": "Check results", "type": "n8n-nodes-base.code", "typeVersion": 2, "position": [1980, 380], "parameters": {"jsCode": "// Check results. The HTTP node returns one item per response, throttled retries included,\n// and not necessarily in batch order. Each batch's GraphQL alias (b0, b1_u0, ...) tells us which batch a result belongs to.\nconst plan = $('Build sync plan').first().json;\nconst batches = $('Split into API batches').all().map(i => i.json);\nconst results = {};          // batch index -> [mutation results]\nlet throttled = 0; const otherErrors = [];\nfor (const { json: r } of $input.all()) {\n  if (JSON.stringify(r.errors || '').includes('THROTTLED')) { throttled++; continue; }\n  if (r.errors) { otherErrors.push(JSON.stringify(r.errors).slice(0, 200)); continue; }\n  for (const [alias, res] of Object.entries(r.data || {})) {\n    const idx = Number(alias.match(/^b(\\d+)/)?.[1]);\n    (results[idx] = results[idx] || []).push(res);\n  }\n}\nlet okStock = 0, okPrice = 0;\nconst errors = [...otherErrors];\nbatches.forEach((b, i) => {\n  if (!results[i]) { errors.push(`${b.kind} batch ${i + 1}: not applied (still throttled or rejected), will retry next run`); return; }\n  for (const res of results[i]) {\n    const ue = res.userErrors || [];\n    ue.forEach(e => errors.push(`${b.kind}: ${e.code ? e.code + ' ' : ''}${e.message}`));\n    // count what Shopify says it actually changed, not what we asked for\n    const ok = b.kind === 'stock'\n      ? ((res.inventoryAdjustmentGroup || {}).changes || []).filter(c => c.name === 'available').length\n      : (res.productVariants || []).length;\n    if (b.kind === 'stock') okStock += ok; else okPrice += ok;\n  }\n});\nconst s = plan.summary;\nconst failed = (s.stockChanges - okStock) + (s.priceChanges - okPrice);\nconst lines = plan.text.split('\\n');\nlines[0] = '*Supplier → Shopify sync* — LIVE';\nlines[2] = `Updated: ${okStock}/${s.stockChanges} stock, ${okPrice}/${s.priceChanges} price · unchanged: ${s.unchanged} · errors: ${failed}` + (throttled ? ` · throttled retries: ${throttled}` : '');\nif (errors.length) lines.push('*Errors:*\\n' + errors.slice(0, 10).map(e => '• ' + e).join('\\n'));\nreturn [{ json: { notify: true, text: lines.join('\\n'), updatedStock: okStock, updatedPrices: okPrice, errors: failed, throttledRetries: throttled } }];\n"}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000012", "name": "Anything to report?", "type": "n8n-nodes-base.filter", "typeVersion": 2.2, "position": [2200, 280], "parameters": {"conditions": {"options": {"caseSensitive": true, "leftValue": "", "typeValidation": "strict", "version": 2}, "conditions": [{"id": "c1", "leftValue": "={{ $json.notify }}", "rightValue": "", "operator": {"type": "boolean", "operation": "true", "singleValue": true}}], "combinator": "and"}, "options": {}}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000013", "name": "Send Slack summary", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [2420, 280], "parameters": {"method": "POST", "url": "={{ $('Config').first().json.slackWebhookUrl }}", "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify({ text: $json.text }) }}", "options": {}}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000014", "name": "On workflow error", "type": "n8n-nodes-base.errorTrigger", "typeVersion": 1, "position": [0, 560], "parameters": {}},
  {"id": "5f0c1e2a-0002-4000-8000-000000000015", "name": "Slack error alert", "type": "n8n-nodes-base.httpRequest", "typeVersion": 4.2, "position": [220, 560], "parameters": {"method": "POST", "url": "https://hooks.slack.com/services/XXX/YYY/ZZZ", "sendBody": true, "specifyBody": "json", "jsonBody": "={{ JSON.stringify({ text: `:warning: *${$json.workflow.name}* failed in node *${$json.execution.lastNodeExecuted || '?'}*\\n${($json.execution.error || {}).message || 'Unknown error'}\\n${$json.execution.url || ''}` }) }}", "options": {}}}
 ],
 "connections": {"Every 6 hours": {"main": [[{"node": "Config", "type": "main", "index": 0}]]}, "Run manually": {"main": [[{"node": "Config", "type": "main", "index": 0}]]}, "Config": {"main": [[{"node": "Get Shopify token", "type": "main", "index": 0}]]}, "Get Shopify token": {"main": [[{"node": "Download supplier feed", "type": "main", "index": 0}]]}, "Download supplier feed": {"main": [[{"node": "Fetch Shopify variants", "type": "main", "index": 0}]]}, "Fetch Shopify variants": {"main": [[{"node": "Build sync plan", "type": "main", "index": 0}]]}, "Build sync plan": {"main": [[{"node": "Dry run or nothing to write?", "type": "main", "index": 0}]]}, "Split into API batches": {"main": [[{"node": "Send updates to Shopify", "type": "main", "index": 0}]]}, "Send updates to Shopify": {"main": [[{"node": "Check results", "type": "main", "index": 0}]]}, "Check results": {"main": [[{"node": "Anything to report?", "type": "main", "index": 0}]]}, "Anything to report?": {"main": [[{"node": "Send Slack summary", "type": "main", "index": 0}]]}, "On workflow error": {"main": [[{"node": "Slack error alert", "type": "main", "index": 0}]]}, "Dry run or nothing to write?": {"main": [[{"node": "Anything to report?", "type": "main", "index": 0}], [{"node": "Split into API batches", "type": "main", "index": 0}]]}},
 "settings": {"executionOrder": "v1"},
 "pinData": {}
}

My products, if you'd rather not maintain this yourself:

Tikkivo Catalog Sync is a full Shopify app for supplier feed syncing.
My Gumroad store has more n8n templates.

The free workflow above works on its own either way. Questions are welcome in the comments.

Note: I used AI tools to help draft this post. Test the workflow in dry-run mode on a development store before using it on a live one.

A free n8n workflow for Shopify low-stock alerts (and 4 gotchas)

Arturas Tikkivo — Mon, 26 Oct 2026 14:48:35 +0000

Shopify tells you a product is sold out. It usually tells you after a customer already tried to buy it. What most small stores actually want is a nudge a few days earlier: "these four variants are running low."

I build Shopify apps and n8n automations, and a low-stock alert looks like a 10-minute job. It isn't, quite. The first version I wrote missed most of the catalog, warned about gift cards, and repeated the same list every four hours until it got muted.

Below is a free, stripped-down workflow you can import, the four gotchas it handles, and a few n8n habits that saved me time. I'm being upfront about testing: I ran it on n8n 2.44.5 against a mock of the Shopify Admin GraphQL API, not a live store. The last section shows how to try it on a free dev store before you trust it.

What the workflow does

Every 4 hours (or when you click Execute workflow) it starts.
Config holds four values: shop URL, API version, threshold and Slack webhook URL.
Get access token swaps your app's client ID and secret for a 24-hour Admin API token.
Fetch all variants calls productVariants in GraphQL and keeps paging until hasNextPage is false.
Find changes filters to active, tracked variants at or below the threshold, then compares them with the last run.
Send to Slack posts one message, but only when something changed.

Six nodes, two triggers, no community nodes.

The workflow (import it)

Copy this, then in n8n open a new workflow and paste with Ctrl/Cmd+V (or use Import from file):

{
  "name": "Shopify low-stock alert (free, by Tikkivo)",
  "nodes": [
    {
      "id": "a1b2c3d4-0001-4000-8000-000000000001",
      "name": "Every 4 hours",
      "type": "n8n-nodes-base.scheduleTrigger",
      "typeVersion": 1.2,
      "position": [
        0,
        0
      ],
      "parameters": {
        "rule": {
          "interval": [
            {
              "field": "hours",
              "hoursInterval": 4
            }
          ]
        }
      }
    },
    {
      "id": "a1b2c3d4-0001-4000-8000-000000000002",
      "name": "Run manually",
      "type": "n8n-nodes-base.manualTrigger",
      "typeVersion": 1,
      "position": [
        0,
        200
      ],
      "parameters": {}
    },
    {
      "id": "a1b2c3d4-0001-4000-8000-000000000003",
      "name": "Config",
      "type": "n8n-nodes-base.set",
      "typeVersion": 3.4,
      "position": [
        220,
        100
      ],
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "id": "c1",
              "name": "shopUrl",
              "value": "https://your-store.myshopify.com",
              "type": "string"
            },
            {
              "id": "c2",
              "name": "apiVersion",
              "value": "2026-10",
              "type": "string"
            },
            {
              "id": "c3",
              "name": "threshold",
              "value": 5,
              "type": "number"
            },
            {
              "id": "c4",
              "name": "slackWebhookUrl",
              "value": "https://hooks.slack.com/services/XXX/YYY/ZZZ",
              "type": "string"
            }
          ]
        },
        "options": {}
      }
    },
    {
      "id": "a1b2c3d4-0001-4000-8000-000000000007",
      "name": "Get access token",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        440,
        100
      ],
      "credentials": {
        "httpCustomAuth": {
          "id": "shopifyAppFree001",
          "name": "Shopify app (client id + secret)"
        }
      },
      "parameters": {
        "method": "POST",
        "url": "={{ $json.shopUrl }}/admin/oauth/access_token",
        "authentication": "genericCredentialType",
        "genericAuthType": "httpCustomAuth",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "{ \"grant_type\": \"client_credentials\" }",
        "options": {}
      }
    },
    {
      "id": "a1b2c3d4-0001-4000-8000-000000000004",
      "name": "Fetch all variants",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        660,
        100
      ],
      "parameters": {
        "method": "POST",
        "url": "={{ $('Config').first().json.shopUrl }}/admin/api/{{ $('Config').first().json.apiVersion }}/graphql.json",
        "sendHeaders": true,
        "headerParameters": {
          "parameters": [
            {
              "name": "X-Shopify-Access-Token",
              "value": "={{ $('Get access token').first().json.access_token }}"
            }
          ]
        },
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={{ JSON.stringify({ query: \"query ($after: String) { productVariants(first: 100, after: $after) { pageInfo { hasNextPage endCursor } nodes { id sku displayName inventoryQuantity inventoryItem { tracked } product { title status } } } }\", variables: { after: null } }) }}",
        "options": {
          "pagination": {
            "pagination": {
              "parameters": {
                "parameters": [
                  {
                    "type": "body",
                    "name": "variables",
                    "value": "={{ { after: $response.body.data.productVariants.pageInfo.endCursor } }}"
                  }
                ]
              },
              "paginationCompleteWhen": "other",
              "completeExpression": "={{ !$response.body.data || !$response.body.data.productVariants.pageInfo.hasNextPage }}",
              "limitPagesFetched": true,
              "maxRequests": 200,
              "requestInterval": 500
            }
          }
        }
      }
    },
    {
      "id": "a1b2c3d4-0001-4000-8000-000000000005",
      "name": "Find changes",
      "type": "n8n-nodes-base.code",
      "typeVersion": 2,
      "position": [
        880,
        100
      ],
      "parameters": {
        "jsCode": "// Free version: flatten pages -> filter -> alert only on CHANGES (dedupe via static data)\nconst cfg = $('Config').first().json;\nconst threshold = Number(cfg.threshold);\n\n// 1) Flatten every page the HTTP node fetched. Fail loudly on GraphQL errors\n//    (Shopify returns HTTP 200 + an \"errors\" array for throttling and missing scopes).\nconst variants = [];\nfor (const page of $input.all()) {\n  if (page.json.errors) throw new Error('Shopify GraphQL error: ' + JSON.stringify(page.json.errors));\n  variants.push(...page.json.data.productVariants.nodes);\n}\n\n// 2) Keep only variants that can really \"run out\"\nconst low = variants.filter(v =>\n  v.product.status === 'ACTIVE' &&      // skip draft/archived products\n  v.inventoryItem.tracked &&            // skip \"don't track quantity\" (gift cards etc.)\n  v.inventoryQuantity <= threshold);\n\n// 3) Compare with what we alerted about last time\nconst memory = $getWorkflowStaticData('global');\nconst before = memory.low || {};                     // { variantId: qty }\nconst now = Object.fromEntries(low.map(v => [v.id, v.inventoryQuantity]));\n\nconst newlyLow = low.filter(v => !(v.id in before));\nconst soldOut  = low.filter(v => v.id in before && before[v.id] > 0 && v.inventoryQuantity <= 0);\nconst restocked = Object.keys(before).filter(id => !(id in now));\n\nmemory.low = now;   // only persisted on production (active, scheduled) runs\n\nif (!newlyLow.length && !soldOut.length && !restocked.length) return [];  // nothing new -> stop quietly\n\nconst line = v => `• ${v.displayName} (${v.sku || 'no SKU'}): ${v.inventoryQuantity} left`;\nconst parts = [];\nif (newlyLow.length) parts.push(`*Low stock (≤ ${threshold}):*\\n` + newlyLow.map(line).join('\\n'));\nif (soldOut.length)  parts.push('*Sold out since last check:*\\n' + soldOut.map(line).join('\\n'));\nif (restocked.length) parts.push(`*Back above ${threshold}:* ${restocked.length} variant(s)`);\n\nreturn [{ json: {\n  text: parts.join('\\n\\n'),\n  scanned: variants.length, pages: $input.all().length,\n  lowNow: low.length, newlyLow: newlyLow.length, soldOut: soldOut.length, restocked: restocked.length,\n} }];"
      }
    },
    {
      "id": "a1b2c3d4-0001-4000-8000-000000000006",
      "name": "Send to Slack",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [
        1100,
        100
      ],
      "parameters": {
        "method": "POST",
        "url": "={{ $('Config').first().json.slackWebhookUrl }}",
        "sendBody": true,
        "specifyBody": "json",
        "jsonBody": "={{ JSON.stringify({ text: $json.text }) }}",
        "options": {}
      }
    }
  ],
  "connections": {
    "Every 4 hours": {
      "main": [
        [
          {
            "node": "Config",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Run manually": {
      "main": [
        [
          {
            "node": "Config",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Config": {
      "main": [
        [
          {
            "node": "Get access token",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Get access token": {
      "main": [
        [
          {
            "node": "Fetch all variants",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch all variants": {
      "main": [
        [
          {
            "node": "Find changes",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Find changes": {
      "main": [
        [
          {
            "node": "Send to Slack",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  },
  "settings": {
    "executionOrder": "v1"
  },
  "pinData": {}
}

Setup takes about five minutes:

Create an app in Shopify's Dev Dashboard with the read_products and read_inventory scopes, and install it on your store. Copy the client ID and secret.
Create the credential in n8n: type Custom Auth, with this JSON: {"body": {"client_id": "YOUR_ID", "client_secret": "YOUR_SECRET"}} Select it in the Get access token node.
Edit Config: your https://your-store.myshopify.com URL, threshold and Slack incoming-webhook URL.
Click Execute workflow, check the Slack message, then activate it.

Gotcha 1: pagination (or: why you only see 100 products)

A GraphQL connection returns one page. If you don't follow pageInfo.endCursor, your alert silently covers the first page of variants and nothing else. Nobody notices until the product that ran out is on page 3.

You don't need a loop with an IF node for this. The HTTP Request node has pagination built in. In Options → Pagination I use "Update a parameter in each request", with a body parameter called variables:

// Pagination parameter (type: body, name: variables)
{{ { after: $response.body.data.productVariants.pageInfo.endCursor } }}

// "Complete when" -> Other -> Complete expression
{{ !$response.body.data || !$response.body.data.productVariants.pageInfo.hasNextPage }}

n8n deep-merges that object into the JSON body, so variables.after is replaced on every request and the query stays intact. Each page comes out as one item, and the Code node flattens them:

const variants = [];
for (const page of $input.all()) {
  if (page.json.errors) throw new Error('Shopify GraphQL error: ' + JSON.stringify(page.json.errors));
  variants.push(...page.json.data.productVariants.nodes);
}

I also set Max pages to 200, so a bug can never turn into an endless loop.

If you're still on REST: it paginates with a Link header and a page_info cursor, not page numbers. Shopify has marked the REST Admin API as legacy, though, so for new work I'd go straight to GraphQL.

Gotcha 2: variants vs inventory levels

inventoryQuantity on a variant is the total across all locations. That's fine for a single warehouse. If you have a shop plus a warehouse, "3 left" might mean three in the shop and none where you ship from.

For per-location alerts, ask the inventory item for its levels instead:

inventoryItem {
  tracked
  inventoryLevels(first: 10) {
    nodes {
      location { name }
      quantities(names: ["available"]) { name quantity }
    }
  }
}

(I haven't run that variant against the mock, so treat it as a starting point.)

Two filters matter just as much as the number:

const low = variants.filter(v =>
  v.product.status === 'ACTIVE' &&   // skip draft/archived products
  v.inventoryItem.tracked &&         // skip "don't track quantity" (gift cards, made-to-order)
  v.inventoryQuantity <= threshold);

Without them you get daily alerts about gift cards and a product you archived last year.

Gotcha 3: rate limits that don't look like errors

Shopify's GraphQL API is rate-limited by query cost, not by request count. Each query has a calculated cost, and your app has a bucket that refills over time. The catch is that a throttled request can come back as HTTP 200 with an errors array (code THROTTLED). The HTTP node sees 200 and carries on happily.

Three things handle it:

first: 100 instead of the maximum 250, so each query stays cheaper.
A 500 ms Interval between requests in the pagination settings.
The throw in the Code node above, so a throttled or permission-denied response fails the execution loudly instead of producing a wrong "all good".

If you want real numbers for your store, look at extensions.cost in a response. It shows the requested cost, the actual cost and the bucket's current state.

Gotcha 4: the same alert every 4 hours

This one kills most stock alerts. If the list doesn't change, the message shouldn't arrive. n8n has a small per-workflow key-value store for exactly this, workflow static data:

const memory = $getWorkflowStaticData('global');
const before = memory.low || {};                      // { variantId: qty }
const now = Object.fromEntries(low.map(v => [v.id, v.inventoryQuantity]));

const newlyLow  = low.filter(v => !(v.id in before));
const soldOut   = low.filter(v => v.id in before && before[v.id] > 0 && v.inventoryQuantity <= 0);
const restocked = Object.keys(before).filter(id => !(id in now));

memory.low = now;
if (!newlyLow.length && !soldOut.length && !restocked.length) return []; // stop quietly

Returning an empty array ends the run there, so Slack is never called and you don't need an IF node.

The caveat that confuses everyone: according to n8n's docs, static data isn't saved when you test in the editor. It's saved on production runs of an active workflow. So in the editor you'll see the full list every time. That's expected, not a bug. (In my test it was also saved when I ran the workflow with the n8n execute CLI.)

The other lessons

Set an error workflow. Create a tiny workflow that starts with an Error Trigger and sends you a message. Then choose it in Workflow settings → Error workflow. A silent failure is worse than no alert, because you think you're covered. Error workflows only fire for production runs, not manual tests.

Keep secrets in credentials, not in Config. The client secret lives in an encrypted n8n credential. Config only holds things you'd be happy to screenshot. One thing to know: the 24-hour access token shows up in that node's saved execution data. If that bothers you, stop saving successful executions in the workflow settings.

Expect tokens to expire. Apps created in the Dev Dashboard get tokens through the client credentials grant, and those tokens last 24 hours. So the workflow fetches a fresh token on every run instead of you pasting one in. If you still have an old app created in the Shopify admin with a permanent shpat_ token, delete the token node and put that token straight into the header.

Pin data while you build. After one real fetch, pin the output of Fetch all variants (the pin icon in the output panel). Then you can rework the Code node and Slack message as often as you like without calling Shopify again. Unpin it before you activate.

How I tested it

I ran it with the n8n CLI against a local mock of the Shopify GraphQL API. The mock serves 8 variants in pages of 3, so pagination really runs. Those variants include a draft product, an untracked gift card and two variants above the threshold. Real output:

=== RUN 1 (first run)
Shopify GraphQL requests: 3   cursors: [None, '3', '6']
Slack messages sent: 1
*Low stock (≤ 5):*
• Amber Candle - Large (CND-01): 0 left
• Amber Candle - Small (CND-02): 3 left
• Linen Tote - Natural (TOTE-1): 4 left
• Clay Mug - Blue (MUG-1): 5 left

=== RUN 2 (nothing changed)
Shopify GraphQL requests: 3
Slack messages sent: 0

=== RUN 3 (CND-02 3->0, TOTE-1 4->20, MUG-2 40->2)
Slack messages sent: 1
*Low stock (≤ 5):*
• Clay Mug - Green (MUG-2): 2 left

*Sold out since last check:*
• Amber Candle - Small (CND-02): 0 left

*Back above 5:* 1 variant(s)

=== RUN 4 (wrong client secret)
n8n exit code 1, 0 GraphQL requests, 0 Slack messages -> execution marked "error"

The draft Oak Board and the untracked gift card never show up, run 2 stays silent, and a bad secret fails instead of posting nonsense.

A mock is only as good as my reading of Shopify's docs, so please try it on a development store first. Create a free dev store from the Dev Dashboard, add a few products with tracked inventory, and set one to 2 and one to 0. Point Config at that store and a test Slack channel, then run it manually. Change a quantity and run it again. Once the messages look right, activate it.

I used AI assistance to help write and edit this post and to build the test setup. The workflow above was run and tested against a mock Shopify API on n8n 2.44.5, not yet on a live store.

My products, if you'd rather not build it yourself: the paid n8n Shopify Low-Stock Alerts template adds per-SKU and tag-based thresholds, Telegram and email, admin links and supplier reorder drafts. And if your stock comes from a supplier's CSV or feed, my Catalog Sync app keeps Shopify prices and quantities in sync with it. The free workflow above works on its own either way. Questions are welcome in the comments.