How to Automate Shopify with n8n (Orders, Customers, and Inventory)

Shopify Automation That Actually Runs

Every Shopify store hits the same wall. You're manually exporting order CSVs to your fulfillment partner. Someone has to tag VIP customers by hand after their third purchase. Low-stock alerts exist in Shopify, but they do not do anything. You still have to open Slack and type the message yourself.

n8n connects directly to Shopify's webhook API and REST Admin endpoints. When an order arrives, a workflow fires (updating your spreadsheet, tagging the customer, notifying the team, and queuing a review request) in under three seconds, without you touching anything.

This guide covers the five most valuable Shopify automation patterns in n8n, with the exact node configuration to implement each one.

What You Can Automate With n8n and Shopify

Any recurring Shopify task is a candidate:

• Order notifications: push new orders to Slack or Discord with line-item details and order value
• Fulfillment status updates: when your 3PL system marks an order shipped, update Shopify fulfillment automatically
• Customer tagging: add tags like vip, repeat-buyer, or at-risk based on order history and spend
• Inventory reorder alerts: fire a Slack alert when any SKU drops below a threshold
• Post-purchase review requests: send a review email 7 days after delivery via your email provider
• Abandoned checkout recovery: trigger a follow-up sequence when a checkout is created but not completed within an hour
• Refund tracking: log every refund to a Google Sheet and notify the finance team in real time

The Shopify Automation Pipeline

All Shopify workflows follow the same structure:

Shopify Trigger (order/created, customer/updated, inventory_level/update)
  → IF / Switch (route by tag, order value, SKU, or customer segment)
  → HTTP Request (fetch additional data from Shopify Admin API if needed)
  → Act (Slack / Email / Google Sheets / CRM / Fulfillment API)
  → Log (append audit row to Google Sheets)

The trigger is always a Shopify webhook. Everything downstream is standard n8n data routing.

1. Collect: Receive the Shopify Event

Use the Shopify Trigger node and subscribe to the event you need:

• order/created: fires when a new order is placed
• order/fulfilled: fires when all line items have tracking numbers
• order/updated: fires on any order change (payment, fulfillment, cancellation)
• customer/created: fires when a new customer account is registered
• inventory_level/update: fires when stock changes for any variant
• checkouts/create: fires when a checkout begins (abandoned cart)

Use one workflow per event type. Combining multiple event types in one workflow creates branching logic that is hard to debug and harder to extend.

2. Process / Segment: Decide What Matters

Not every order warrants the same action. Use an IF or Switch node to route by order value, product type, or customer history:

order/created
  → IF: total_price >= 200   → high-value path
  → ELSE                     → standard path

To check customer lifetime value, use an HTTP Request node to fetch the full customer record before branching:

GET /admin/api/2024-01/customers/{customer_id}.json
X-Shopify-Access-Token: YOUR_TOKEN

Then branch on orders_count, total_spent, or the presence of a specific tag.

3. Route: Handle Each Segment

Build a sub-path for each branch. Common routing patterns:

• New customer, first order → welcome email + tag customer new
• Repeat customer (3+ orders) → tag vip, add to loyalty segment in your email platform
• Order over $500 → Slack alert to sales channel + create a follow-up task in your CRM
• Digital product → skip fulfillment flow, deliver download link via email immediately

Keep each path short: 3–5 nodes is ideal. If a path grows complex, move it into a sub-workflow and call it with the Execute Workflow node.

4. Act: Write to Every System That Needs to Know

The action layer is where most of the value lives. Common patterns:

Slack notification for high-value orders:

POST https://hooks.slack.com/services/YOUR_WEBHOOK
{
  "text": "New order: $200+ from a returning customer. Check Shopify for details."
}

Use a Code node to format the message with fields from the trigger payload before passing it to the Slack node.

Google Sheets order log:

Use the Google Sheets node in Append mode:

• Columns: order_id, customer_email, total_price, created_at, fulfillment_status
• One row per order, every run

CRM contact upsert:

Use an HTTP Request to your CRM's batch upsert endpoint with the customer's email as the unique key. This keeps your CRM current without a separate nightly sync job.

5. Follow Up: Close the Loop

Two follow-up patterns are worth adding to every Shopify workflow:

Error alerting: If any action node fails, route to a Slack message with the order ID and error text. This prevents silent failures where an order processed but the CRM never got updated.

Post-purchase review request: Trigger on order/fulfilled, insert a Wait node set to 7 days, then send a review request email via Gmail or your transactional email provider. One workflow, no external scheduling tool required.

Implementation Patterns

Pattern 1: Inventory Reorder Alert

Trigger on inventory_level/update. Check if the available quantity is at or below your reorder threshold. If true, fetch the variant to get the SKU and product title, then send a Slack alert.

Shopify Trigger (inventory_level/update)
  → IF: available <= 10
    → HTTP Request: GET /variants/{variant_id}.json
    → Code: format message with SKU + product title
    → Slack: "Low stock: [SKU], [N] units remaining. Reorder now."

You can make the threshold dynamic by storing reorder levels in a Google Sheet and looking them up by SKU in the Code node.

Pattern 2: Abandoned Checkout Recovery

Trigger on checkouts/create. Wait 1 hour with a Wait node. Then fetch the checkout by token to check if it was completed. If completed_at is null, the cart was abandoned. Send a recovery email.

Shopify Trigger (checkouts/create)
  → Wait: 1 hour
  → HTTP Request: GET /admin/api/.../checkouts/{token}.json
  → IF: completed_at == null
    → Email: Send abandoned cart recovery with product names and checkout URL

This pattern requires the read_checkouts API scope on your private app.

Pattern 3: VIP Customer Tagging

Trigger on order/created. Fetch the full customer record to get lifetime order count and spend. In a Code node, evaluate VIP criteria. If met, PATCH the customer to add the vip tag and log them to a tracking sheet.

Shopify Trigger (order/created)
  → HTTP Request: GET /customers/{customer_id}.json
  → Code: check if orders_count >= 3 AND total_spent >= 500
  → IF: qualifies
    → HTTP Request: PATCH /customers/{id}.json  (add tag "vip")
    → Google Sheets: append row to VIP tracker
    → Slack: notify account team in #vip-customers

For a more sophisticated version that also handles win-back campaigns, see the Membership Churn Monitor and Winback template.

n8n Nodes You'll Use Most

Getting Started

1. Install n8n: self-host with Docker (docker run -p 5678:5678 n8nio/n8n) or use n8n Cloud.
2. Create a Shopify private app: in Shopify Admin, go to Settings > Apps > Develop apps. Create an app, grant the Admin API scopes you need (read_orders, write_customers, read_inventory), and copy the access token.
3. Add Shopify credentials in n8n: go to Credentials, create a new Shopify credential, and paste your shop domain and access token.
4. Build your first workflow: start with order notifications: Shopify Trigger (order/created) → Slack node. Place a test order to verify the trigger fires correctly.
5. Add routing: once the basic trigger works, insert an IF node and build the VIP tagging path alongside the standard path.
6. Expand the event coverage: duplicate and adapt the workflow for inventory_level/update and order/fulfilled to automate the full order lifecycle.
7. Start from a template: use a pre-built post-purchase sequence template or the Competitor Price Intelligence template to monitor your market position alongside order data.

For the full picture of e-commerce automation beyond Shopify (including abandoned cart recovery across platforms, multi-channel inventory, and post-purchase upsells), see the complete n8n e-commerce automation guide.

If your Shopify workflows need to respond instantly to external events from payment processors or shipping APIs, the n8n webhook automation guide covers real-time trigger patterns in depth.