Shopify & E-commerce

Shopify webhooks in n8n explained, without the jargon: a webhook is a message your store fires to a URL the instant something happens, like a new order landing or a product selling out. Instead of your automation nagging Shopify every few minutes to ask what changed, Shopify pushes the event to you the moment it occurs. This guide shows what webhooks are, why they beat scheduled polling for a Shopify store, and how to build a validated three node workflow that pings your phone on Telegram the second an order comes in.

What it does

The demo workflow watches a single Shopify event, the orders/create topic, and turns every new order into an instant Telegram message. When a customer checks out, Shopify delivers the full order payload to n8n, a Set node formats it into a short human readable summary, and a Telegram node sends it to your chat. You get a ping like this within a second of the sale:

🛒 New order #1042
Customer: Emily Rodriguez
Total: 128.40 USD
Items: 3
  

No dashboard refreshing, no email digest that arrives an hour late. The order alert reaches you while the customer is still on the thank you page. Once you understand this pattern, the same webhook plumbing drives every other real time Shopify automation you will ever build in n8n.

Why it beats the default

The common alternative is polling: a Schedule trigger that asks Shopify for recent orders every few minutes. Polling works, but it has three real costs. It is slow, because your alert is only as fresh as the interval, so a five minute schedule means a five minute delay. It is wasteful, because most of those requests return nothing new yet still count against your Shopify API rate limit. And it is fragile, because you have to track which orders you already saw to avoid sending duplicate alerts.

A webhook flips all three. Shopify only contacts you when the event genuinely happens, so the alert is near instant, you spend zero API calls waiting for nothing, and every delivery is a distinct event so there is no de-duplication logic to maintain. For anything that should feel live, a webhook is the correct tool.

What you need

• An n8n instance, either n8n Cloud or self hosted, version 1.0 or newer.
• A Shopify store where you can create a custom app for API access. Follow our 2026 guide to connecting Shopify to n8n first, since the Shopify Trigger needs an access token credential.
• A Telegram account and a bot token from BotFather, plus your numeric chat ID for the destination.
• About 15 minutes to build from scratch, or 2 minutes with the ready made template.

Node-by-node list

Three nodes, one straight line. Here is what each one is and why it exists.

• Shopify order webhook — a Shopify Trigger node set to the orders/create topic. This is the webhook. It registers the subscription with Shopify and fires once per new order, handing the full order object to the next node.
• Build alert message — a Set (Edit Fields) node that reads the order fields and composes one tidy string. This keeps the message logic separate from the sending, so you can restyle the alert without touching Telegram.
• Send Telegram alert — a Telegram node that posts the composed message to your chat. Swap it for a Gmail node later if you prefer email; the first two nodes stay identical.

┌──────────────────────────────────────────────────────────────┐
│  SHOPIFY WEBHOOK → TELEGRAM ORDER ALERT                        │
│                                                                │
│  [Shopify order webhook] → [Build alert message] → [Telegram]  │
│    orders/create             Set / Edit Fields       send      │
└──────────────────────────────────────────────────────────────┘
  

Step-by-step build

1. Create a new workflow in n8n and add a Shopify Trigger node. In its settings, set Authentication to Access Token and pick the Shopify credential you created in the connection guide.
2. In the same node, set the Topic to orders/create. That single choice tells Shopify to notify n8n every time an order is placed. Leave everything else at its default.
3. Add a Set node (also called Edit Fields) and connect the trigger to it. Add one assignment named message of type String.
4. Paste this expression as the value of message, using the expression editor so the {{ }} parts resolve against the order:

   🛒 New order {{ $json.name }}
   Customer: {{ $json.customer.first_name }} {{ $json.customer.last_name }}
   Total: {{ $json.total_price }} {{ $json.currency }}
   Items: {{ $json.line_items.length }}

5. Add a Telegram node and connect the Set node to it. Choose your Telegram credential, set Resource to Message and Operation to Send Message.
6. In the Telegram node, set Chat ID to your numeric chat ID, and set Text to the expression {{ $json.message }} so it sends the string the Set node built.
7. Click Save, then toggle the workflow Active. Activating it is what registers the real webhook with Shopify. Place a test order, or use Shopify’s webhook test button, and watch the alert arrive in Telegram.

Common mistakes

• Building the whole thing but never toggling the workflow Active. In test mode the webhook is temporary, so live orders never reach it. The permanent subscription exists only while the workflow is on.
• Referencing a customer field on a guest checkout that has none. If some orders come in without a customer object, guard the expression, for example {{ $json.customer?.first_name || "Guest" }}, so the Set node never errors.
• Using the wrong topic. orders/create fires on new orders; orders/paid fires only after payment clears. Pick the one that matches the moment you actually care about.
• Expecting duplicate protection from n8n. Webhooks are one event per delivery, so if you also keep an old polling workflow running you will get two alerts. Retire the poller once the webhook works.

Cost at realistic volume

This workflow is close to free at any small store volume. Shopify does not charge for webhook deliveries. Telegram bot messages are free. On n8n Cloud, each order alert is a single execution, so a store doing 40 orders a day uses about 1,200 executions a month, which sits inside the entry paid tier. Self hosted n8n has no per execution cost at all.

The only line item to watch is your n8n Cloud plan’s execution allowance. If order volume climbs into the thousands per day, self hosting removes that ceiling entirely.

Frequently asked questions

Related guides

• How to connect Shopify to n8n in 2026 — the credential setup this workflow depends on.
• Shopify alerts on Telegram with n8n — more real time notifications built on the same trigger.
• The complete guide to n8n Shopify automation — every store workflow in one hub.
• Browse all Shopify automation guides.
• The n8n template library
• Best n8n AI agent templates for Shopify

This n8n Shopify node guide shows you exactly what the built-in Shopify node can do for a store owner, and how to wire it into a workflow that reads and writes real order data. Instead of hand-building Admin API calls, you pick a resource and an operation and fill in a few fields. To make it concrete, you will build a small workflow that checks for high-value orders every hour, tags them as VIP, and emails you a digest, all with the native node.

What it does

The Shopify node is n8n’s official connector for a Shopify store. It talks to the Shopify Admin API on your behalf, so you never write a raw request. You choose a resource (Order, Product, Customer) and an operation (Get, Get Many, Create, Update, Delete), and the node builds and sends the call.

The demo in this guide uses two of those operations back to back. First it reads recent orders with Order, Get Many. Then, for any order over a threshold, it writes a tag back with Order, Update. A short Code node formats a summary and Gmail sends it to you. It is a compact tour of the node’s two most common jobs, reading store data and pushing a change back.

Before any of this works, your Shopify credential has to be connected. If you have not done that yet, follow how to connect Shopify to n8n in 2026 first, which walks through the current Dev Dashboard method and the access token the node needs.

Why it beats the default

The manual alternative is an HTTP Request node pointed at https://your-store.myshopify.com/admin/api/2026-04/orders.json, with headers, query strings, and pagination you maintain by hand. That works, but every field is yours to get right, and a version bump or a typo in the header breaks it silently.

The built-in Shopify node removes most of that surface area:

• Authentication is handled by the stored credential, so no access token sits in a header field.
• Pagination is automatic when you turn on Return All, so you are not writing a loop over page_info cursors.
• Operations are named in plain language, so Update an order is a dropdown choice, not a PUT you assemble.
• Filters like Created At Min are labelled fields, not query parameters you have to remember.

You reach for a raw HTTP Request node only when you need an endpoint the node does not expose. For everyday order, product, and customer work, the node is faster to build and far easier to hand to someone else later.

What you need

• An n8n instance (Cloud or self-hosted).
• A Shopify store with a custom app / access token connected as an n8n credential. See the 2026 connection guide.
• A Gmail account connected to n8n for the digest (or swap in Slack, Telegram, or plain SMTP).
• About 20 minutes to build from scratch, or two minutes with the ready-to-import template below.

This pattern is one of many in our n8n Shopify automation hub; the node covered here is the building block behind most of them.

Node-by-node list

  [Every hour]
       |
  [Shopify: Get Many Orders]  --- reads recent orders
       |
  [Filter: total >= $200]
       |
  [Shopify: Update Order + VIP tag]  --- writes a change back
       |
  [Build digest] --> [Gmail: email you]

Step-by-step build

1. Add a Schedule Trigger. Set the rule to run every 1 hour. This is the entry point; polling on a schedule means the workflow runs even on Shopify plans without webhook access.
2. Add the Shopify node to read orders. Set Resource to Order and Operation to Get Many. Turn on Return All. Under options, set Created At Min to the expression ={{ $now.minus({ hours: 1 }).toISO() }} and Status to any. This pulls only orders from the last hour, which keeps the call small.
3. Add a Filter node. Create one condition: left value ={{ $json.total_price }}, operator number is greater than or equal to, right value 200. Orders below the threshold stop here.
4. Add the Shopify node to write the tag. Set Resource to Order, Operation to Update, and Order ID to ={{ $json.id }}. In Update Fields, add Tags with the expression ={{ $json.tags ? $json.tags + ', VIP' : 'VIP' }}. That appends VIP to whatever tags the order already had.
5. Add a Code node. Set it to Run Once for All Items and paste the digest script (included in the template) that turns the tagged orders into an HTML list with order numbers and totals.
6. Add a Gmail node. Set To to your address, Subject to ={{ $json.count }} new VIP orders tagged, and Message to ={{ $json.html }}.
7. Attach credentials and save. Point both Shopify nodes at your store credential and the Gmail node at your Gmail credential, then toggle the workflow Active.

Common mistakes

Overwriting tags instead of appending

Shopify stores tags as a single comma-separated string, and Update replaces the whole field. If you set Tags to just VIP, you erase every other tag on the order. Always read $json.tags first and append, as the expression above does.

Fetching the whole store every run

Turning on Return All with no date filter pulls your entire order history each hour. On a busy store that is thousands of records and needless API load. The Created At Min filter keeps each run to just the new orders.

Comparing price as text

Shopify returns total_price as a string like "249.00". Use a number comparison in the Filter so "90.00" is not treated as greater than "200.00" by alphabetical order. n8n’s loose type validation handles the conversion when the operator type is number.

Skipping the connection step

A red error on the Shopify node almost always means no credential is attached or the access token lacks a scope. Confirm the token has read_orders and write_orders using the connection guide before debugging anything else.

Cost at realistic volume

The node itself is free; you pay only for the tools around it. On n8n Cloud, one hourly run is 24 executions a day, about 720 a month, comfortably inside the Starter plan’s allowance. Self-hosted n8n is unlimited on your own server.

Even if you raise the schedule to every 15 minutes, you are still well under typical plan limits, because each run touches only the last window of orders.

Frequently asked questions

Related guides

• How to connect Shopify to n8n (2026) — the credential setup this node depends on.
• n8n Shopify automation hub — the full library of store workflows.
• All Shopify guides — every tutorial in one place.
• Browse the full n8n template library

A Shopify product catalog sync to Notion keeps a Notion database mirrored to your live store, so your team plans merchandising, content, and pricing against real product data instead of a stale copy-paste. This guide builds the n8n workflow that pulls every product from Shopify on a schedule and upserts it into Notion, creating new pages and refreshing changed ones automatically. It is free to follow start to finish, and a ready-to-import template is linked below if you would rather skip the build.

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

What it does

This is a one-way, scheduled sync from Shopify to a Notion database. On a fixed interval, n8n asks the Shopify Admin API for your products, breaks the response into one item per product, and normalizes each one into a flat set of fields: title, SKU, price, total inventory, status, vendor, and a storefront link. For every product it then checks whether a matching page already lives in your Notion catalog, keyed on the Shopify product ID.

If a page exists, the workflow updates its price, inventory, and status. If it does not, the workflow creates a new page. The result is a Notion database that stays a faithful mirror of your catalog without anyone exporting a CSV. Notion becomes the planning surface your marketing, content, and ops people already live in, backed by live store data. This is one of the building blocks in our wider n8n Shopify automation library.

┌───────────────────────────────────────────────────────────────┐
│  SHOPIFY  ->  NOTION CATALOG SYNC                              │
│                                                               │
│  [Every 6 hours] -> [Get products] -> [Split] -> [Map fields] │
│                                                     │         │
│                                          [Find page in Notion]│
│                                                     │         │
│                                              [Page exists?]   │
│                                              /               │
│                                    [Update page]   [Create page]
└───────────────────────────────────────────────────────────────┘
  

Why it beats the default

The default way teams keep a product list in Notion is a manual export. You download a CSV from Shopify, paste it into a Notion table, and it is already out of date by the time you finish. Prices change, stock drops, a product gets archived, and the Notion copy quietly drifts from reality until nobody trusts it.

Notion has no native Shopify integration, so the usual alternative is a per-task automation platform. Those work, but they bill per operation. A catalog of a few hundred products checked several times a day burns through task quotas fast, and the cost climbs with your catalog. This n8n version runs on a flat plan or on your own server, upserts instead of blindly appending, so it never leaves duplicate rows, and it costs the same whether you sync 50 products or 5,000.

What you need

• An n8n instance, either n8n Cloud or self-hosted. Any recent version works.
• A Shopify store with an Admin API access token that has read_products scope. Create it through the 2026 Shopify Developer Dashboard and connect it to n8n as described in connect Shopify to n8n (2026). This workflow calls Admin API version 2026-04.
• A Notion internal integration token, and a Notion database shared with that integration.

Your Notion database needs these properties, with these exact names and types, so the workflow can write to them:

Node-by-node list

1. Every 6 hours (Schedule Trigger): fires the sync on a fixed interval.
2. Get Shopify products (HTTP Request): GET /admin/api/2026-04/products.json?limit=250.
3. Split into products (Split Out): turns the products array into one item per product.
4. Map product fields (Edit Fields): normalizes each product into flat fields for Notion.
5. Find existing page (Notion, Get Many database pages): searches Notion for a page whose Shopify ID matches.
6. Page exists? (IF): routes on whether a matching page was found.
7. Update Notion page (Notion, Update): refreshes price, inventory, and status on the existing page.
8. Create Notion page (Notion, Create): adds a new catalog page for products not yet in Notion.

Step-by-step build

1. Add a Schedule Trigger. Set it to run every 6 hours. This is the only trigger in the workflow.
2. Add an HTTP Request node named Get Shopify products. Method GET, URL https://YOUR_STORE.myshopify.com/admin/api/2026-04/products.json?limit=250. Under Authentication choose Generic Credential Type, then Header Auth, and attach your Shopify token credential (header X-Shopify-Access-Token).
3. Add a Split Out node named Split into products. Set Field To Split Out to products. The Shopify response is one object with a products array, so this hands the rest of the flow one item per product.
4. Add an Edit Fields node named Map product fields. Create string and number assignments that pull from each product:
   • product_id = {{ $json.id.toString() }}
   • product_title = {{ $json.title }}
   • sku = first variant SKU
   • price = first variant price, as a number
   • inventory = sum of variant inventory quantities
   • status, vendor, and a storefront_url built from the handle
5. Add a Notion node named Find existing page. Resource Database Page, operation Get Many. Pick your database, set Return All off with Limit 1, and add a filter: your Shopify ID property equals {{ $json.product_id }}. In the node Settings tab, turn on Always Output Data so the node still emits an item when no page is found.
6. Add an IF node named Page exists?. Condition: {{ $json.id }} is not empty. When Notion returned a page it carries an id; when it found nothing the item is empty, so the true branch means update and the false branch means create.
7. On the true branch, add a Notion node named Update Notion page. Operation Update, Page ID {{ $json.id }}. Map Price, Inventory, Status, SKU, and Storefront from the earlier node with {{ $('Map product fields').item.json.price }} and the like.
8. On the false branch, add a Notion node named Create Notion page. Operation Create, pick the same database. Set the title to the product title and map Shopify ID, Price, Inventory, Status, SKU, Vendor, and Storefront from Map product fields.
9. Wire it up: Schedule Trigger to Get Shopify products to Split into products to Map product fields to Find existing page to Page exists?, then the two branches to Update and Create.
10. Save, run once manually, and check your Notion database. Run it a second time to confirm existing pages update rather than duplicate.

Common mistakes

• Forgetting Always Output Data on the search node. Without it, a product with no existing Notion page produces zero items, the IF never fires, and new products silently never get created. This is the single most common reason the sync appears to work but never adds anything.
• Catalogs over 250 products. One request returns at most 250. Shopify paginates with a Link header cursor. Add a loop that follows page_info until the header is empty, or move to the GraphQL Admin API with cursor pagination.
• Notion property name or type drift. n8n writes by property name. If Notion has Stock but the node writes Inventory, that column stays blank with no error. Keep names and types aligned with the table above.
• Status Select options missing. If your Status property does not already contain the option being written, Notion may reject it. Pre-create active, draft, and archived, or allow n8n to add options.
• Rate limits on large catalogs. The per-product loop calls Notion for every item. Notion allows roughly three requests per second. For big catalogs, add a small Loop Over Items batch or a short Wait so you stay under the limit.

Cost at realistic volume

All three services carry this workflow for free or close to it. The Shopify Admin API and the Notion API are both free to call at this scale. n8n Cloud counts workflow executions, not nodes or items, so a run every six hours is about 120 executions a month regardless of catalog size, which sits comfortably inside the Starter plan. Self-hosted n8n is free outright.

Because n8n bills per execution rather than per operation, the cost does not grow with your catalog. The same run that syncs 500 products syncs 5,000 for the same execution count.

Frequently asked questions

Related guides

• Connect Shopify to n8n (2026) — the credential setup this workflow depends on.
• Sync Shopify orders to Airtable with n8n — the same upsert idea, applied to orders.
• The n8n Shopify automation hub — every Shopify workflow in one place.
• Browse more in the Shopify automation category.
• The n8n template library

A Shopify new product announcement should go out the moment a product goes live, not whenever you next remember to write an email. This n8n workflow watches your store for new products and, the instant one is created, drafts a short launch blurb with Google Gemini, emails your subscriber list through Gmail, and posts the same news to a Telegram channel. No copy-paste, no scheduling, no missed launches. Below is the full build, the exact node setup, and a ready-to-import template.

What it does

The workflow connects three moving parts around one event: a product being created in Shopify. When that happens, it pulls the product title, price, image, vendor, and URL, sends that data to Gemini for a two-sentence announcement, then fans the finished message out to two channels at once.

• You publish a new product in Shopify as you normally would.
• n8n catches the products/create event automatically.
• Gemini writes a short, upbeat launch line from the product details.
• Your email list receives a clean HTML announcement through Gmail.
• Your Telegram channel gets the same news posted at the same moment.

For a first look at how Shopify data reaches n8n, the pillar guide on n8n Shopify automation covers the connection basics that this workflow builds on.

Why it beats the default

Shopify has no built-in “announce this product everywhere” button. The manual routine is familiar: add the product, switch to your email tool, write a subject line, paste the product link, find the image, hit send, then repeat the whole thing in your Telegram community. Every step is a chance to delay, to forget, or to send a broken link.

Shopify Flow can react to product events, but it lives inside Shopify and cannot post to an arbitrary Telegram channel or call Gemini for copy. Zapier can, but you pay per task and stitching two destinations plus an AI step onto one trigger adds up fast. With n8n you own the logic, run it on the free tier or your own server, and pay nothing per announcement. One event, two channels, AI-written copy, zero recurring task fees.

What you need

• An n8n instance (cloud or self-hosted). New to it? Start with the pillar on n8n Shopify automation.
• A Shopify custom app access token. Follow connect Shopify to n8n (2026 method) for the current Dev Dashboard flow.
• A Gmail account for the broadcast (free tier sends up to 500 messages per day).
• A Google Gemini API key (free tier, gemini-2.5-flash).
• A Telegram bot token and a channel where the bot is an admin.

Build time: about 30 minutes from scratch, or under 10 minutes with the template at the end of this guide.

Node-by-node list

Six nodes, in a straight line that splits into two at the end. Here is the full map before we configure anything.

  SHOPIFY NEW PRODUCT ANNOUNCEMENT

  [New product created]        Shopify Trigger  (products/create)
          |
  [Extract product fields]     Set              (title, price, image, url)
          |
  [Write blurb with Gemini]    HTTP Request     (Gemini generateContent)
          |
  [Build email and message]    Set              (email HTML + Telegram text)
          |
     +----+----+
     |         |
 [Email the  [Post to Telegram
  list]        channel]
 Gmail         Telegram

Step-by-step build

1. New product created (Shopify Trigger)

Add a Shopify Trigger node. Set Authentication to Access Token and attach your Shopify credential. Under Topic, choose products/create. n8n registers the webhook with Shopify for you, so nothing needs configuring inside the Shopify admin. When you save and activate the workflow, every newly created product will push its full payload here.

2. Extract product fields (Set)

Add a Set (Edit Fields) node. The raw Shopify payload is large, so pull out only what the announcement needs. Create these assignments:

title   = {{ $json.title }}
handle  = {{ $json.handle }}
price   = {{ $json.variants[0].price }}
image   = {{ $json.image.src }}
vendor  = {{ $json.vendor }}
url     = https://YOUR_STORE.myshopify.com/products/{{ $json.handle }}

Replace YOUR_STORE with your store subdomain, or use your primary domain if you have one attached. After this node the data is small and predictable:

{
  "title": "Cedar & Sage Travel Candle",
  "handle": "cedar-sage-travel-candle",
  "price": "24.00",
  "image": "https://cdn.shopify.com/s/files/1/candle.jpg",
  "vendor": "Northwind Goods",
  "url": "https://yourstore.myshopify.com/products/cedar-sage-travel-candle"
}

3. Write blurb with Gemini (HTTP Request)

Add an HTTP Request node. Set the method to POST and the URL to the Gemini endpoint:

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

Set Authentication to Generic Credential Type, then Header Auth, and attach a header credential holding x-goog-api-key with your Gemini key as the value. Under Body, choose JSON and paste:

{
  "contents": [
    { "parts": [
      { "text": "Write a short launch announcement for a new online store product. Two sentences, under 40 words, upbeat but not salesy, no emojis, no hashtags. Product name: {{ $json.title }}. Price: {{ $json.price }}. Brand: {{ $json.vendor }}." }
    ] }
  ],
  "generationConfig": { "temperature": 0.7, "maxOutputTokens": 120 }
}

Gemini returns the copy at candidates[0].content.parts[0].text, which the next node reads.

4. Build email and message (Set)

Add a second Set node to assemble both outputs. Reference the earlier node by name so the product data and the Gemini blurb combine cleanly.

blurb        = {{ $json.candidates[0].content.parts[0].text.trim() }}

emailHtml    = <h2>Just launched: {{ $('Extract product fields').item.json.title }}</h2>
               <p>{{ $json.candidates[0].content.parts[0].text.trim() }}</p>
               <p><strong>Price:</strong> {{ $('Extract product fields').item.json.price }}</p>
               <p><a href="{{ $('Extract product fields').item.json.url }}">Shop it now</a></p>

telegramText = New product: {{ $('Extract product fields').item.json.title }}
               {{ blurb }}
               Price: {{ $('Extract product fields').item.json.price }}
               {{ $('Extract product fields').item.json.url }}

5. Email the list (Gmail)

Add a Gmail node set to Send. Put your list or Google Group address in To (for example announcements@yourstore.com). Set Subject to New arrival: {{ $('Extract product fields').item.json.title }}, choose HTML as the email type, and set the message to {{ $json.emailHtml }}. Attach your Gmail OAuth2 credential.

6. Post to Telegram channel (Telegram)

Add a Telegram node set to Send Message. In Chat ID, enter your channel username such as @yourstore_news. Set the text to {{ $json.telegramText }} and attach your Telegram bot credential. Connect both this node and the Gmail node to the output of Build email and message so they run in parallel.

Common mistakes

• Announcing a bulk import. The products/create topic fires once per product. Deactivate the workflow before importing a catalog, then turn it back on.
• Putting the Gemini key in the URL. Use a Header Auth credential with x-goog-api-key so the key stays out of logs.
• Bot not an admin. A Telegram bot cannot post to a channel it does not administer. Add it as an admin first.
• Wrong price field. Price lives at variants[0].price, not on the product root. Products with no variant will error, so guard the expression if you sell single-variant and multi-variant items.
• Draft products triggering. Depending on how you publish, unfinished drafts can fire the event. Add a Filter node checking status is active if that is a problem.

Cost at realistic volume

Assume a store that launches 20 new products a month, each announced to an email list and a Telegram channel.

At this volume the entire pipeline runs for nothing. The only point where cost enters is email scale: once your list grows past a few hundred recipients, Gmail is the wrong tool and you would route the send through a dedicated email service, which is a one-node swap.

Frequently asked questions

Related guides

• n8n Shopify automation — the pillar guide covering every store workflow.
• Connect Shopify to n8n (2026 method) — the access-token setup this workflow needs.
• Shopify alerts on Telegram with n8n — order and inventory alerts to the same channel.
• More in the Shopify category.
• Browse the full n8n template library
• Best n8n AI agent templates for Shopify

Shopify API authentication in n8n is the step that stalls most store owners before a single workflow runs, usually with a blunt 401 Unauthorized and no clue why. This guide clears it up: the difference between a custom app access token and OAuth2, which one your store actually needs, how to attach the credential to both the Shopify node and a plain HTTP Request, the scopes that matter, and a repeatable way to catch a broken connection before your automations quietly fail.

New to connecting Shopify and n8n at all? Start with the 2026 Shopify to n8n connection walkthrough first, then come back here for the auth mechanics and error fixes.

What it does

This guide gives you two things. First, a clear model of how Shopify authenticates API calls and how n8n plugs into that model, so you stop guessing. Second, a small, importable workflow that puts the theory to work: it calls the Shopify shop.json endpoint on a schedule using your credential, checks the response, and pings Telegram the moment authentication breaks. That last part matters because a revoked token or an expired API version fails silently, and you often only notice when a day of orders never synced.

Shopify offers two authentication methods for the Admin API, and n8n supports both as native credential types:

• Custom app access token — a single permanent token you create inside your own store’s admin. This is the right choice for automating one store you control.
• OAuth2 — the standard install flow used when an app connects to stores owned by other people. n8n runs the OAuth handshake and stores the resulting token for you.

Why it beats the default

The instinct is to paste an API key straight into an HTTP Request node and move on. That works until it does not, and when it fails the error is always the same unhelpful 401. The approach here is better for three reasons.

You create the credential once and reuse it everywhere. Both the Shopify node and any HTTP Request node point at the same stored credential, so rotating a token is a one-place change instead of a hunt through every workflow. n8n injects the X-Shopify-Access-Token header for you, so the token never sits in plain text inside a node parameter or an exported JSON file. And because the same credential drives the raw HTTP calls, you can reach endpoints the Shopify node does not expose, like shop.json, without a second set of keys.

The health-check pattern on top of that turns authentication from a thing you hope still works into a thing you get told about. Six times a day it proves the token is valid, and if it is not, you hear about it in Telegram in seconds rather than in a customer complaint next week.

What you need

• An n8n instance, cloud or self-hosted, version 1.0 or newer.
• A Shopify store where you are staff with permission to create a custom app. Custom apps are created through the store admin at Settings → Apps and sales channels → Develop apps, which Shopify surfaces via the modern Dev Dashboard flow. See the connection walkthrough for the click-by-click on generating the token.
• A Telegram bot token and your chat ID, for the failure alert. Swap in Gmail if you prefer email.
• Roughly 20 minutes to build from scratch, or a couple of minutes with the template below.

Node-by-node list

The workflow is six nodes and one clean path with a single branch at the end.

[Every 6 Hours]      Schedule trigger
      |
[Store Config]       your myshopify domain + API version
      |
[Call Shop Endpoint] HTTP Request -> GET /admin/api/2026-04/shop.json
      |               (Shopify Access Token credential, neverError on)
[Auth OK?]           IF statusCode == 200
      |------ true  --> [Healthy Summary]   Set node, records the shop name
      |------ false --> [Send Auth Alert]   Telegram warning with the status code
  

Step-by-step build

1. Create the Shopify credential. In n8n go to Credentials, click New, and search for Shopify Access Token API. Enter your store’s subdomain (the part before .myshopify.com), the API key and secret from your custom app, and the access token. Save it. This is the custom app token method. For OAuth2, pick Shopify OAuth2 API instead and complete the Connect flow in the browser.
2. Add the Schedule Trigger. Drop a Schedule Trigger node and set the interval to every 6 hours. This is your entry point.
3. Add a Set node named Store Config. Create two string fields: shopDomain set to your-store.myshopify.com and apiVersion set to 2026-04. Keeping these in one place means you never hunt through a URL to change the version.
4. Add the HTTP Request node. Set method to GET and the URL to =https://{{ $json.shopDomain }}/admin/api/{{ $json.apiVersion }}/shop.json. Under Authentication choose Predefined Credential Type, then set the credential type to Shopify Access Token API and select the credential you made in step 1. This is the key move: the HTTP node reuses the Shopify credential and adds the auth header for you.
5. Make the request forgiving. In the HTTP node’s Options, add Response and turn on Full Response and Never Error. Full Response exposes the status code; Never Error stops a 401 from halting the run so your IF node can react to it.
6. Add the IF node named Auth OK? Set the condition to Number, left value ={{ $json.statusCode }}, operation equals, right value 200.
7. Wire the true branch to a Set node. Name it Healthy Summary and write one string field, for example =Shopify API OK — {{ $json.body.shop.name }} (plan: {{ $json.body.shop.plan_name }}). Send this to a log, a sheet, or nowhere; the point is a clean success record.
8. Wire the false branch to Telegram. Set the chat ID to your own and the text to something like =Shopify API auth failed — HTTP {{ $json.statusCode }}. Check the token, scopes, and API version. Save the workflow and toggle it Active.

Common mistakes

• Using a custom domain in the URL. The Admin API only answers on your-store.myshopify.com, never on your storefront domain. A request to the pretty domain returns 401 or 404.
• Missing scopes. A token is valid but scoped. If a workflow reads orders, the custom app needs read_orders; for products, read_products. The shop.json check works with a minimal token, so a health check can pass while a real workflow still 401s on a resource whose scope you forgot to grant.
• Confusing OAuth2 with the token method. Picking Shopify OAuth2 API for a store you own means running an install flow you do not need. For your own store, the access token credential is simpler and never expires.
• Leaving the API version stale. An old version in the URL keeps working until Shopify retires it, then every call fails at once. Pin a recent version like 2026-04 and bump it on a calendar reminder.
• Copying the token with a trailing space. A stray space or newline pasted into the credential is a classic silent 401. Retype the last character if a fresh token still fails.
• Not turning on Never Error. Without it, a 401 throws and the IF branch never runs, so your alert never fires and the failure stays invisible.

Cost at realistic volume

This one is close to free. The health check makes four API calls a day, about 120 a month, which is nothing against Shopify’s rate limit of two requests per second on the standard REST bucket. Telegram messaging is free. On self-hosted n8n your only cost is the server you already run. On n8n Cloud, four scheduled executions a day sit comfortably inside the Starter plan’s monthly execution allowance, so the marginal cost of running this is effectively zero. The token and the Shopify Admin API themselves cost nothing on any Shopify plan.

Frequently asked questions

Related guides

• How to connect Shopify to n8n in 2026 — the prerequisite connection walkthrough.
• n8n Shopify automation hub — every workflow that runs on this same credential.
• All Shopify automation guides — the full library.
• All ready-to-import n8n templates

Ecommerce automation with n8n lets you wire your store to the tools you already use, such as Google Sheets, Telegram, Gmail, and your CRM, without paying for a stack of single-purpose apps. This guide maps the workflows worth building first, explains why n8n beats the default app-per-task approach, and walks you through a working starter automation that logs every new order to a spreadsheet and pings you on Telegram the moment it lands.

What ecommerce automation with n8n actually covers

n8n is an open-source automation tool. You build workflows on a visual canvas by connecting nodes: something triggers the flow (a new order, a schedule, a low-stock event), the data gets shaped, and one or more actions fire (a row appended, an email sent, a channel pinged). For an online store, that maps onto a handful of jobs you run over and over. Here are the ones most stores automate first, each with a full how-to if you want to go deep on that one.

Orders and fulfillment

• Log every new order to Google Sheets for a running sales ledger your accountant can actually open.
• Get order alerts on Telegram so you see revenue land in real time without refreshing the admin.
• Auto-tag orders by value, location, or product so fulfillment can filter at a glance.
• Send branded shipping confirmations with tracking, on your terms instead of the default template.

Inventory and catalog

• Low-stock alerts before you sell something you cannot ship.
• Auto-email suppliers a reorder when a SKU drops below its threshold.
• Generate product descriptions with AI from a title and a few bullet points.

Customers and retention

• Recover abandoned checkouts with a timed email sequence.
• Follow up after purchase to ask for a review or cross-sell.
• Win back lapsed buyers automatically once they go quiet.
• Segment customers by RFM so your best buyers get your best offers.
• Answer support questions with an AI chatbot trained on your own store data.

That is the roundup. If you run Shopify specifically, the n8n Shopify automation hub is the deeper index of every Shopify build on this site. This page is the broader ecommerce view, and every workflow above works just as well on WooCommerce through its own node. New to connecting a store at all? Start with connecting Shopify to n8n, or the WooCommerce setup guide.

Why it beats the default

The default path is one app per task. An app for order alerts, another for spreadsheet exports, another for review requests, each with its own monthly fee and its own dashboard. Three or four of those and you are paying more every month than a whole automation platform costs, with data scattered across tools that do not talk to each other.

n8n flips that. One instance owns all of it, and the workflows share data. The same order that gets logged to a sheet can trigger the low-stock check and the customer tag in the same run. A few concrete advantages:

• Flat cost. Self-hosted n8n runs unlimited executions on a 5-dollar VPS. You are not billed per task or per contact.
• No platform lock-in. The Shopify node and the WooCommerce node live in the same tool, so switching or running both stores is a node swap, not a rebuild.
• You own the logic. Export any workflow as JSON, back it up, share it, or move it to another server. Nothing is trapped behind a vendor account.
• Composable. Every workflow can call the next. That is impossible when each task lives in a separate closed app.

What you need

To build the starter workflow below (a new order that logs to a sheet and alerts you on Telegram) you need four things:

• An n8n instance, cloud or self-hosted. The workflow imports the same on either.
• A Shopify store connected to n8n with an Admin API access token. Follow the 2026 connection guide first if you have not done this. (On WooCommerce, swap the trigger for the WooCommerce Trigger node; the rest is identical.)
• A Google account with a blank spreadsheet to receive the order rows.
• A Telegram bot token and your chat ID for the alert. Message @BotFather to create a bot, and @userinfobot to read your chat ID.

Build time: about 20 minutes from scratch, or under 5 minutes if you import the ready-made template below.

Node-by-node list

The starter is four nodes. Data flows from the trigger, gets shaped once, then fans out to both actions in parallel.

  New Shopify Order  -->  Build Order Summary  -->  Log to Google Sheets
     (trigger)             (Set fields)          
                                                   -->  Send Telegram Alert
  

Step-by-step build

1. Add the trigger. Drop in a Shopify Trigger node, set Authentication to Access Token, attach your Shopify credential, and set the topic to orders/create. n8n registers the webhook with Shopify for you.
2. Shape the data. Add an Edit Fields (Set) node. Create five string fields so the rest of the flow works with clean values instead of the deep order object:

   order_number   = {{ $json.order_number }}
   customer_name  = {{ $json.customer.first_name }} {{ $json.customer.last_name }}
   total          = {{ $json.total_price }}
   currency       = {{ $json.currency }}
   placed_at      = {{ $json.created_at }}

3. Log to the sheet. Add a Google Sheets node, operation Append Row. Pick your spreadsheet and the Orders tab, then map the columns to the five fields above (Order, Customer, Total, Currency, Placed at).
4. Send the alert. Add a Telegram node, operation Send Message. Paste your chat ID and set the text to an expression:

   New order {{ $json.order_number }}
   Customer: {{ $json.customer_name }}
   Total: {{ $json.total }} {{ $json.currency }}

5. Fan out in parallel. Wire the Set node to both the Google Sheets node and the Telegram node. One output can feed two nodes, so a single order is logged and alerted in the same run.
6. Save and activate. Save the workflow, toggle it Active, and place a test order (or use a Shopify test payment). A row appears in your sheet and a message hits Telegram within seconds.

Common mistakes

• Referencing the raw order everywhere. Without the Set node, each action digs into $json.customer.first_name and friends on its own. One payload change and you fix it in five places. Shape once, reference the clean field.
• Chaining actions instead of fanning out. If you wire Sheets, then Telegram after it, a Sheets error blocks the alert. Branch both off the Set node so they run independently.
• Wrong Shopify auth. The removed legacy custom-app flow no longer applies. Use an Admin API access token via the 2026 Dev Dashboard method, or the trigger throws a 401.
• Header row mismatch. The Google Sheets append maps by column name. If your sheet header says Order # but the mapping says Order, the value lands in the wrong place or a new column.
• Testing with the workflow inactive. The Shopify Trigger only receives live webhooks when the workflow is Active. In the editor, use Execute Node with a sample, but confirm end to end with the workflow switched on.

Cost at realistic volume

Say you take 1,000 orders a month. Every order runs this workflow once, so that is 1,000 executions. Here is what that actually costs across the pieces:

Compare that to a dedicated order-alert app plus a separate spreadsheet-sync app, each billed monthly and often per order or per contact. The n8n version replaces both for a flat fee, and it does not get more expensive as you add the next workflow to the same instance.

Frequently asked questions

Related guides

• All Shopify automation guides
• The n8n Shopify automation hub
• How to connect Shopify to n8n (2026 method)
• Automating a WooCommerce store with n8n
• Shopify order alerts on Telegram
• The n8n template library

Auto-hide out-of-stock WooCommerce products with n8n and you stop losing sales to dead-end product pages. This guide builds a small workflow that scans your catalog on a schedule, moves any sold-out product to draft so it disappears from the storefront, and then quietly re-publishes it the moment stock comes back. No plugin subscription, no manual list to maintain, and a safety flag so it never touches drafts you created yourself.

What it does

A shopper who lands on a permanently sold-out product is a shopper who leaves. The default WooCommerce behavior keeps that page live, indexed, and clickable, showing an “out of stock” notice that reads like a closed door. This workflow closes the loop automatically.

On a schedule you control, it asks WooCommerce two questions: which published products are out of stock, and which of the products I previously hid are back in stock. Sold-out products get set to draft so they vanish from collections, search, and Google’s next crawl. Restocked products that the workflow hid earlier get flipped back to publish. Everything else is left alone.

The result is a storefront that only ever shows things a customer can actually buy, kept in sync without anyone remembering to check.

Why it beats the default

WooCommerce can show a “sold out” badge, but it will not remove the product from the catalog for you, and the free core has no built-in “hide when out of stock, show when restocked” toggle. The common alternatives each have a catch:

• Manually setting products to draft works until you have more than a handful of SKUs, then it becomes a chore you forget.
• A dedicated hide-out-of-stock plugin adds another paid subscription and another thing to keep updated, for one narrow job.
• Catalog visibility filters hide products from some views but often leave the direct URL live and indexable.

An n8n workflow owns the whole rule in one place: hide on sell-out, restore on restock, and never re-publish a product you deliberately left as a draft. You can read every step, change the schedule, or extend it later. If you run Shopify instead of WooCommerce, the same pattern is covered in our Shopify auto-hide out-of-stock guide, and the broader n8n Shopify automation hub lists the rest of the store workflows you can wire up the same way.

What you need

• A running n8n instance (self-hosted free edition or any n8n Cloud plan).
• A WooCommerce store on WordPress with the REST API enabled (it is on by default).
• A WooCommerce API key pair (Consumer Key and Consumer Secret) with Read/Write access. If you have not connected WooCommerce to n8n before, our WooCommerce to n8n guide walks through generating that key.
• About 20 minutes to build from scratch, or a couple of minutes if you import the template below.

Node-by-node list

The whole thing is five core nodes, no AI and no paid add-ons:

1. Every hour — Schedule Trigger. Fires the scan on an interval you set.
2. Get out-of-stock live products — HTTP Request (GET). Pulls published products whose stock_status is outofstock.
3. Get hidden back-in-stock products — HTTP Request (GET). Pulls draft products that are back instock.
4. Decide hide or restore — Code node. Tags each product with the action to take and builds the update body, using a meta flag as a safety gate.
5. Update product visibility — HTTP Request (PUT). Writes the new status back to WooCommerce, one product per item.

┌───────────────────────────────────────────────────────────────┐
│  AUTO-HIDE OUT-OF-STOCK WOOCOMMERCE PRODUCTS                   │
│                                                               │
│  [Every hour]                                                 │
│      ├──> [Get out-of-stock live products] ─┐                 │
│      └──> [Get hidden back-in-stock prods] ─┤                 │
│                                             v                 │
│                                [Decide hide or restore]       │
│                                             v                 │
│                                [Update product visibility]    │
└───────────────────────────────────────────────────────────────┘
  

Step-by-step build

1. Add a Schedule Trigger node, name it Every hour, and set the rule to an interval of hours with a value of 1.
2. Add an HTTP Request node named Get out-of-stock live products. Set method to GET and URL to https://YOUR_STORE.com/wp-json/wc/v3/products. Under Authentication choose Predefined Credential Type and pick WooCommerce API. Turn on Send Query Parameters and add three: status=publish, stock_status=outofstock, and per_page=100.
3. Duplicate that node, name the copy Get hidden back-in-stock products, and change the query parameters to status=draft, stock_status=instock, and per_page=100.
4. Wire the Schedule Trigger to both HTTP GET nodes so they run in parallel on every fire.
5. Add a Code node named Decide hide or restore and connect both GET nodes into it. Paste the logic below. It reads every incoming product, decides whether to hide or restore it, and builds the exact body WooCommerce needs.

const out = [];
for (const item of $input.all()) {
  const p = item.json;
  const meta = Array.isArray(p.meta_data) ? p.meta_data : [];
  const flag = meta.find((m) => m.key === '_auto_hidden_oos');

  if (p.status === 'publish' && p.stock_status === 'outofstock') {
    out.push({ json: { id: p.id, name: p.name, action: 'hide',
      body: { status: 'draft',
        meta_data: [{ key: '_auto_hidden_oos', value: 'yes' }] } } });
  } else if (p.status === 'draft' && p.stock_status === 'instock'
             && flag && flag.value === 'yes') {
    out.push({ json: { id: p.id, name: p.name, action: 'restore',
      body: { status: 'publish',
        meta_data: [{ key: '_auto_hidden_oos', value: '' }] } } });
  }
}
return out;

6. Add a final HTTP Request node named Update product visibility. Set method to PUT and URL to https://YOUR_STORE.com/wp-json/wc/v3/products/{{ $json.id }}. Use the same WooCommerce API credential. Turn on Send Body, set Body Content Type to JSON, and set the JSON body to the expression {{ JSON.stringify($json.body) }}.
7. Connect Decide hide or restore into it. Because the Code node emits one item per product, this node runs once per product and updates each independently.
8. Save, then click Execute Workflow to run a manual test. Check a sold-out product in wp-admin: its status should now read Draft. Restock it, run again, and confirm it flips back to Published.
9. When it behaves, toggle the workflow Active so the schedule takes over.

Common mistakes

• Read-only API keys. The PUT step needs Read/Write. A key created with Read access returns a 401 on update while the GET steps still work, which makes the failure look mysterious. Regenerate the key with Read/Write.
• A trailing slash or wrong protocol in the store URL. Use https://yourstore.com/wp-json/wc/v3/products with no trailing slash and make sure the site is on HTTPS, or WooCommerce rejects the signed request.
• Forgetting pagination on large catalogs. per_page=100 handles one page. If you routinely have more than 100 out-of-stock products at once, add a loop that increments the page parameter until the response comes back empty.
• Restoring by stock alone. If you drop the meta-flag check and re-publish every in-stock draft, you will push half-finished products live. Keep the flag.value === 'yes' condition.
• Running the scan too often. Every minute is wasteful and hammers your store. Hourly is plenty for almost everyone.

Cost at realistic volume

This workflow is effectively free to run. It uses only core n8n nodes, so there is no AI token spend and no premium node requirement.

An hourly run is roughly 720 executions a month, each a couple of quick API calls. On self-hosted n8n that is zero marginal cost; on Cloud it is a rounding error against your plan’s included executions.

FAQ

Related guides

• Auto-hide out-of-stock Shopify products with n8n
• Connect WooCommerce to n8n: the migration guide
• The n8n Shopify automation hub
• More ecommerce automation guides
• Browse the full n8n template library

A Shopify storefront FAQ RAG chatbot built with n8n, Gemini and Supabase answers shopper questions using your own catalog and policy pages instead of a generic script. Shoppers ask “does this ship to Texas?” or “what is your return window?” and get a grounded answer pulled from your real store data. This guide builds the whole thing with Google Gemini and a Supabase vector store, so it stays free to run at small volume and never sends a shopper an invented policy.

What it does

Most storefront chat widgets either forward every message to a human or run on a static decision tree that breaks the moment a shopper phrases a question differently. Retrieval augmented generation (RAG) fixes that. You embed your store’s real content once, and the chatbot retrieves the most relevant pieces to answer each question in the shopper’s own words.

There are two flows in this template. The first is an ingestion flow: it pulls your Shopify products and your shop policies, turns them into clean text, and stores them as vectors in Supabase. The second is a chat flow: a hosted chat widget takes a shopper question, searches Supabase for the closest matching content, and lets Gemini write a short, grounded reply.

INGESTION (run on demand or nightly)
  Manual/Schedule -> Get Products (Shopify) --.
                  -> Get Policies (HTTP) ------> Merge -> Build Documents -> Supabase (Insert)
                                                                              ^  Gemini Embeddings
                                                                              ^  Data Loader + Splitter

CHAT (always on)
  Chat widget -> Storefront AI Agent -> reply
                    |-- Gemini Chat Model
                    |-- Store Knowledge tool -> Supabase (retrieve) -> Gemini Embeddings
  

If you have already built a general document chatbot, this is the store-specific cousin of our Drive and Supabase document chatbot. The difference here is the knowledge source: your live product catalog and policies, not files in a folder.

Why it beats the default

A canned FAQ widget only knows the answers you hard-coded. Add a product, change your return window, or run a sale, and the widget is instantly wrong. This RAG setup reads from the same catalog your storefront shows, so it is right by construction as long as you re-run ingestion when things change.

It also beats a plain large language model with no retrieval. Ask a bare model about your shipping policy and it will happily guess. Because this agent is told to answer only from the store_knowledge tool and to defer to support when unsure, it does not fabricate prices or policies, which is exactly the failure mode that gets stores in trouble. For open-ended support tickets and order lookups, pair it with our Shopify AI customer support chatbot; this template focuses on pre-sale storefront questions.

What you need

• An n8n instance (Cloud or self-hosted, community edition is fine).
• A Shopify store and a custom app token. Follow our 2026 guide to connect Shopify to n8n using the Dev Dashboard method, with the read_products and read_content scopes.
• A Google Gemini API key (free tier) for embeddings and chat.
• A Supabase project (free tier) with the pgvector extension enabled and a documents table plus a match_documents function.

Node-by-node list

Ingestion flow

1. When clicking Test workflow — Manual Trigger. Kicks off ingestion (swap for Schedule Trigger later).
2. Get Products (Shopify) — Shopify node, product / Get All, returns your whole catalog.
3. Get Policies (HTTP) — HTTP Request to the Admin API policies.json endpoint for shipping, refund and privacy text.
4. Merge Sources — Merge node in append mode, combining products and policies into one stream.
5. Build Documents — Code node that strips HTML and formats each product and policy into a clean text block.
6. Supabase (Insert) — Supabase Vector Store in insert mode, writing embeddings to the documents table.
7. Gemini Embeddings (Ingest) — embeddings sub-node feeding the insert step.
8. Data Loader — Default Data Loader that reads the text field and attaches metadata.
9. Text Splitter — Recursive Character Text Splitter, 1000-character chunks with 100 overlap.

Chat flow

10. When chat message received — Chat Trigger, the hosted storefront widget.
11. Storefront AI Agent — AI Agent that must call the knowledge tool before answering.
12. Gemini Chat Model — gemini-2.5-flash, the language model behind the agent.
13. Store Knowledge (Supabase) — Supabase Vector Store in retrieve-as-tool mode, top 5 matches.
14. Gemini Embeddings (Query) — embeds the shopper’s question so it can be matched.

Step-by-step build

1. Prepare Supabase. In your Supabase project, enable the vector extension, then create a documents table and a match_documents function using the n8n template SQL, with the embedding column set to vector(768).
2. Add the Manual Trigger. Drop in When clicking Test workflow as the ingestion entry point.
3. Pull products. Add the Shopify node, choose resource Product and operation Get All, enable Return All, and attach your Shopify credential.
4. Pull policies. Add an HTTP Request node, method GET, URL https://YOUR_STORE.myshopify.com/admin/api/2026-04/policies.json, authentication set to Predefined Credential Type, Shopify API. Connect the Manual Trigger to both this and the Shopify node.
5. Merge the two sources. Add the Merge node in append mode. Wire Shopify into input 1 and the HTTP node into input 2.
6. Build clean documents. Add the Code node. It loops the merged items, detects the policies array versus product fields, strips HTML tags, and outputs one item per document with a text field and source/title metadata.
7. Wire the vector store (insert). Add the Supabase Vector Store node in Insert mode, table documents. Attach the Gemini Embeddings sub-node, a Default Data Loader reading {{ $json.text }}, and a Recursive Character Text Splitter under the loader.
8. Run ingestion once. Click Test workflow. Confirm rows appear in the Supabase documents table.
9. Add the chat flow. Drop in the Chat Trigger and an AI Agent. Set the agent system message so it answers only from the store_knowledge tool and defers to support when unsure.
10. Attach the model and tool. Connect a Gemini Chat Model (gemini-2.5-flash) and a second Supabase Vector Store in retrieve-as-tool mode named store_knowledge, with its own Gemini Embeddings sub-node.
11. Test the chat. Open the chat URL and ask a real question like “what is your return policy?” Confirm the agent retrieves and answers from your data.

Common mistakes

• Wrong vector size. Creating the Supabase column as vector(1536) (the OpenAI default) breaks inserts. Gemini text-embedding-004 is 768 dimensions.
• Different embedding models per flow. The ingest and query embeddings must use the same model. Both nodes here use text-embedding-004 on purpose; do not change one without the other.
• Skipping the “answer only from the tool” instruction. Without it the agent will invent shipping times and prices. The system message is the guardrail.
• Missing scopes. If policies come back empty, your Shopify token is missing read_content. Products need read_products.
• Never re-ingesting. RAG is only as current as your last ingestion run. Schedule it or trigger it on catalog changes.

Cost at realistic volume

For a store with a few hundred products and a handful of policy pages, this runs at or near zero. Gemini’s free tier covers the embeddings and the chat volume of a small storefront, and Supabase’s free tier holds the vectors comfortably.

At larger volume you would move Gemini to pay-as-you-go, where flash pricing keeps a busy storefront in the low single digits of dollars per month, and optionally upgrade Supabase for more storage. The architecture does not change.

FAQ

Related guides

• The complete guide to n8n Shopify automation
• Shopify AI customer support chatbot with n8n
• AI document chatbot with n8n, Google Drive and Supabase
• How to connect Shopify to n8n in 2026
• More Shopify automation guides
• All ready-to-import n8n templates
• Best n8n AI agent templates for Shopify